Left Termination of the query pattern mergesort_in_3(g, a, a) w.r.t. the given Prolog program could not be shown:



↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof

Clauses:

mergesort([], [], Ls).
mergesort(.(X, []), .(X, []), Ls).
mergesort(.(X, .(Y, Xs)), Ys, .(H, Ls)) :- ','(split(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)), ','(mergesort(X1s, Y1s, Ls), ','(mergesort(X2s, Y2s, Ls), merge(Y1s, Y2s, Ys, .(H, Ls))))).
split([], [], [], Ls).
split(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) :- split(Xs, Zs, Ys, Ls).
merge([], Xs, Xs, Ls).
merge(Xs, [], Xs, Ls).
merge(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) :- ','(le(X, Y), merge(Xs, .(Y, Ys), Zs, Ls)).
merge(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) :- ','(gt(X, Y), merge(.(X, Xs), Ys, Zs, Ls)).
gt(s(X), s(Y)) :- gt(X, Y).
gt(s(0), 0).
le(s(X), s(Y)) :- le(X, Y).
le(0, s(0)).
le(0, 0).

Queries:

mergesort(g,a,a).

We use the technique of [30]. With regard to the inferred argument filtering the predicates were used in the following modes:
mergesort_in: (b,f,f)
split_in: (b,f,f,b) (f,f,f,f)
merge_in: (b,b,f,b) (f,b,f,f) (b,f,f,f)
le_in: (f,f)
gt_in: (f,f)
Transforming Prolog into the following Term Rewriting System:
Pi-finite rewrite system:
The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag([], [], [], Ls) → split_out_gaag([], [], [], Ls)
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(Xs, [], Xs, Ls) → merge_out_agaa(Xs, [], Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
merge_in_gaaa([], Xs, Xs, Ls) → merge_out_gaaa([], Xs, Xs, Ls)
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x2, x3)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x3)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)

Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog



↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
  ↳ PrologToPiTRSProof

Pi-finite rewrite system:
The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag([], [], [], Ls) → split_out_gaag([], [], [], Ls)
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(Xs, [], Xs, Ls) → merge_out_agaa(Xs, [], Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
merge_in_gaaa([], Xs, Xs, Ls) → merge_out_gaaa([], Xs, Xs, Ls)
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x2, x3)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x3)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)


Using Dependency Pairs [1,30] we result in the following initial DP problem:
Pi DP problem:
The TRS P consists of the following rules:

MERGESORT_IN_GAA(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_GAA(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
MERGESORT_IN_GAA(.(X, .(Y, Xs)), Ys, .(H, Ls)) → SPLIT_IN_GAAG(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))
SPLIT_IN_GAAG(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_GAAG(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
SPLIT_IN_GAAG(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → SPLIT_IN_AAAA(Xs, Zs, Ys, Ls)
SPLIT_IN_AAAA(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_AAAA(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
SPLIT_IN_AAAA(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → SPLIT_IN_AAAA(Xs, Zs, Ys, Ls)
U1_GAA(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U1_GAA(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → MERGESORT_IN_GAA(X1s, Y1s, Ls)
U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_GAA(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → MERGESORT_IN_GAA(X2s, Y2s, Ls)
U3_GAA(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_GAA(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
U3_GAA(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → MERGE_IN_GGAG(Y1s, Y2s, Ys, .(H, Ls))
MERGE_IN_GGAG(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_GGAG(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
MERGE_IN_GGAG(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → LE_IN_AA(X, Y)
LE_IN_AA(s(X), s(Y)) → U11_AA(X, Y, le_in_aa(X, Y))
LE_IN_AA(s(X), s(Y)) → LE_IN_AA(X, Y)
U6_GGAG(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_GGAG(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U6_GGAG(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → LE_IN_AA(X, Y)
U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_AGAA(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → GT_IN_AA(X, Y)
GT_IN_AA(s(X), s(Y)) → U10_AA(X, Y, gt_in_aa(X, Y))
GT_IN_AA(s(X), s(Y)) → GT_IN_AA(X, Y)
U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_AGAA(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → LE_IN_AA(X, Y)
U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_GAAA(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → GT_IN_AA(X, Y)
U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_GAAA(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)
MERGE_IN_GGAG(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_GGAG(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
MERGE_IN_GGAG(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → GT_IN_AA(X, Y)
U8_GGAG(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_GGAG(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U8_GGAG(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)

The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag([], [], [], Ls) → split_out_gaag([], [], [], Ls)
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(Xs, [], Xs, Ls) → merge_out_agaa(Xs, [], Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
merge_in_gaaa([], Xs, Xs, Ls) → merge_out_gaaa([], Xs, Xs, Ls)
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x2, x3)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x3)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)
U8_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GAAA(x8)
U10_AA(x1, x2, x3)  =  U10_AA(x3)
U2_GAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_GAA(x7, x8)
U9_GGAG(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_GGAG(x8)
U1_GAA(x1, x2, x3, x4, x5, x6, x7)  =  U1_GAA(x7)
LE_IN_AA(x1, x2)  =  LE_IN_AA
U5_GAAG(x1, x2, x3, x4, x5, x6, x7)  =  U5_GAAG(x7)
U6_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_AGAA(x8)
U6_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_GAAA(x8)
U6_GGAG(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_GGAG(x8)
MERGESORT_IN_GAA(x1, x2, x3)  =  MERGESORT_IN_GAA(x1)
U9_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_AGAA(x8)
MERGE_IN_AGAA(x1, x2, x3, x4)  =  MERGE_IN_AGAA(x2)
U7_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GAAA(x8)
SPLIT_IN_GAAG(x1, x2, x3, x4)  =  SPLIT_IN_GAAG(x1, x4)
U7_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_AGAA(x8)
SPLIT_IN_AAAA(x1, x2, x3, x4)  =  SPLIT_IN_AAAA
MERGE_IN_GAAA(x1, x2, x3, x4)  =  MERGE_IN_GAAA(x1)
U7_GGAG(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GGAG(x8)
U3_GAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_GAA(x7, x8)
U8_GGAG(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GGAG(x8)
U8_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_AGAA(x8)
U5_AAAA(x1, x2, x3, x4, x5, x6, x7)  =  U5_AAAA(x7)
GT_IN_AA(x1, x2)  =  GT_IN_AA
MERGE_IN_GGAG(x1, x2, x3, x4)  =  MERGE_IN_GGAG(x1, x2, x4)
U9_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_GAAA(x8)
U11_AA(x1, x2, x3)  =  U11_AA(x3)
U4_GAA(x1, x2, x3, x4, x5, x6, x7)  =  U4_GAA(x7)

We have to consider all (P,R,Pi)-chains

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
  ↳ PrologToPiTRSProof

Pi DP problem:
The TRS P consists of the following rules:

MERGESORT_IN_GAA(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_GAA(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
MERGESORT_IN_GAA(.(X, .(Y, Xs)), Ys, .(H, Ls)) → SPLIT_IN_GAAG(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))
SPLIT_IN_GAAG(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_GAAG(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
SPLIT_IN_GAAG(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → SPLIT_IN_AAAA(Xs, Zs, Ys, Ls)
SPLIT_IN_AAAA(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_AAAA(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
SPLIT_IN_AAAA(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → SPLIT_IN_AAAA(Xs, Zs, Ys, Ls)
U1_GAA(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U1_GAA(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → MERGESORT_IN_GAA(X1s, Y1s, Ls)
U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_GAA(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → MERGESORT_IN_GAA(X2s, Y2s, Ls)
U3_GAA(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_GAA(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
U3_GAA(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → MERGE_IN_GGAG(Y1s, Y2s, Ys, .(H, Ls))
MERGE_IN_GGAG(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_GGAG(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
MERGE_IN_GGAG(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → LE_IN_AA(X, Y)
LE_IN_AA(s(X), s(Y)) → U11_AA(X, Y, le_in_aa(X, Y))
LE_IN_AA(s(X), s(Y)) → LE_IN_AA(X, Y)
U6_GGAG(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_GGAG(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U6_GGAG(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → LE_IN_AA(X, Y)
U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_AGAA(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → GT_IN_AA(X, Y)
GT_IN_AA(s(X), s(Y)) → U10_AA(X, Y, gt_in_aa(X, Y))
GT_IN_AA(s(X), s(Y)) → GT_IN_AA(X, Y)
U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_AGAA(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → LE_IN_AA(X, Y)
U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_GAAA(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → GT_IN_AA(X, Y)
U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_GAAA(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)
MERGE_IN_GGAG(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_GGAG(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
MERGE_IN_GGAG(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → GT_IN_AA(X, Y)
U8_GGAG(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_GGAG(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U8_GGAG(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)

The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag([], [], [], Ls) → split_out_gaag([], [], [], Ls)
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(Xs, [], Xs, Ls) → merge_out_agaa(Xs, [], Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
merge_in_gaaa([], Xs, Xs, Ls) → merge_out_gaaa([], Xs, Xs, Ls)
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x2, x3)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x3)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)
U8_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GAAA(x8)
U10_AA(x1, x2, x3)  =  U10_AA(x3)
U2_GAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_GAA(x7, x8)
U9_GGAG(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_GGAG(x8)
U1_GAA(x1, x2, x3, x4, x5, x6, x7)  =  U1_GAA(x7)
LE_IN_AA(x1, x2)  =  LE_IN_AA
U5_GAAG(x1, x2, x3, x4, x5, x6, x7)  =  U5_GAAG(x7)
U6_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_AGAA(x8)
U6_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_GAAA(x8)
U6_GGAG(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_GGAG(x8)
MERGESORT_IN_GAA(x1, x2, x3)  =  MERGESORT_IN_GAA(x1)
U9_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_AGAA(x8)
MERGE_IN_AGAA(x1, x2, x3, x4)  =  MERGE_IN_AGAA(x2)
U7_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GAAA(x8)
SPLIT_IN_GAAG(x1, x2, x3, x4)  =  SPLIT_IN_GAAG(x1, x4)
U7_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_AGAA(x8)
SPLIT_IN_AAAA(x1, x2, x3, x4)  =  SPLIT_IN_AAAA
MERGE_IN_GAAA(x1, x2, x3, x4)  =  MERGE_IN_GAAA(x1)
U7_GGAG(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GGAG(x8)
U3_GAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_GAA(x7, x8)
U8_GGAG(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GGAG(x8)
U8_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_AGAA(x8)
U5_AAAA(x1, x2, x3, x4, x5, x6, x7)  =  U5_AAAA(x7)
GT_IN_AA(x1, x2)  =  GT_IN_AA
MERGE_IN_GGAG(x1, x2, x3, x4)  =  MERGE_IN_GGAG(x1, x2, x4)
U9_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_GAAA(x8)
U11_AA(x1, x2, x3)  =  U11_AA(x3)
U4_GAA(x1, x2, x3, x4, x5, x6, x7)  =  U4_GAA(x7)

We have to consider all (P,R,Pi)-chains
The approximation of the Dependency Graph [30] contains 5 SCCs with 25 less nodes.

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
                ↳ UsableRulesProof
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
  ↳ PrologToPiTRSProof

Pi DP problem:
The TRS P consists of the following rules:

GT_IN_AA(s(X), s(Y)) → GT_IN_AA(X, Y)

The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag([], [], [], Ls) → split_out_gaag([], [], [], Ls)
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(Xs, [], Xs, Ls) → merge_out_agaa(Xs, [], Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
merge_in_gaaa([], Xs, Xs, Ls) → merge_out_gaaa([], Xs, Xs, Ls)
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x2, x3)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x3)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)
GT_IN_AA(x1, x2)  =  GT_IN_AA

We have to consider all (P,R,Pi)-chains
For (infinitary) constructor rewriting [30] we can delete all non-usable rules from R.

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
  ↳ PrologToPiTRSProof

Pi DP problem:
The TRS P consists of the following rules:

GT_IN_AA(s(X), s(Y)) → GT_IN_AA(X, Y)

R is empty.
The argument filtering Pi contains the following mapping:
s(x1)  =  s(x1)
GT_IN_AA(x1, x2)  =  GT_IN_AA

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ NonTerminationProof
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

GT_IN_AA → GT_IN_AA

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by semiunifying a rule from P directly.

The TRS P consists of the following rules:

GT_IN_AA → GT_IN_AA

The TRS R consists of the following rules:none


s = GT_IN_AA evaluates to t =GT_IN_AA

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:



Rewriting sequence

The DP semiunifies directly so there is only one rewrite step from GT_IN_AA to GT_IN_AA.





↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
  ↳ PrologToPiTRSProof

Pi DP problem:
The TRS P consists of the following rules:

LE_IN_AA(s(X), s(Y)) → LE_IN_AA(X, Y)

The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag([], [], [], Ls) → split_out_gaag([], [], [], Ls)
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(Xs, [], Xs, Ls) → merge_out_agaa(Xs, [], Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
merge_in_gaaa([], Xs, Xs, Ls) → merge_out_gaaa([], Xs, Xs, Ls)
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x2, x3)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x3)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)
LE_IN_AA(x1, x2)  =  LE_IN_AA

We have to consider all (P,R,Pi)-chains
For (infinitary) constructor rewriting [30] we can delete all non-usable rules from R.

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
  ↳ PrologToPiTRSProof

Pi DP problem:
The TRS P consists of the following rules:

LE_IN_AA(s(X), s(Y)) → LE_IN_AA(X, Y)

R is empty.
The argument filtering Pi contains the following mapping:
s(x1)  =  s(x1)
LE_IN_AA(x1, x2)  =  LE_IN_AA

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ NonTerminationProof
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

LE_IN_AA → LE_IN_AA

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by semiunifying a rule from P directly.

The TRS P consists of the following rules:

LE_IN_AA → LE_IN_AA

The TRS R consists of the following rules:none


s = LE_IN_AA evaluates to t =LE_IN_AA

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:



Rewriting sequence

The DP semiunifies directly so there is only one rewrite step from LE_IN_AA to LE_IN_AA.





↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
              ↳ PiDP
              ↳ PiDP
  ↳ PrologToPiTRSProof

Pi DP problem:
The TRS P consists of the following rules:

U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)
U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))

The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag([], [], [], Ls) → split_out_gaag([], [], [], Ls)
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(Xs, [], Xs, Ls) → merge_out_agaa(Xs, [], Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
merge_in_gaaa([], Xs, Xs, Ls) → merge_out_gaaa([], Xs, Xs, Ls)
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x2, x3)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x3)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)
U8_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GAAA(x8)
U6_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_AGAA(x8)
U6_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_GAAA(x8)
MERGE_IN_AGAA(x1, x2, x3, x4)  =  MERGE_IN_AGAA(x2)
MERGE_IN_GAAA(x1, x2, x3, x4)  =  MERGE_IN_GAAA(x1)
U8_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_AGAA(x8)

We have to consider all (P,R,Pi)-chains
For (infinitary) constructor rewriting [30] we can delete all non-usable rules from R.

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
              ↳ PiDP
              ↳ PiDP
  ↳ PrologToPiTRSProof

Pi DP problem:
The TRS P consists of the following rules:

U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)
U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))

The TRS R consists of the following rules:

le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))

The argument filtering Pi contains the following mapping:
.(x1, x2)  =  .
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
s(x1)  =  s(x1)
U8_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GAAA(x8)
U6_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_AGAA(x8)
U6_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_GAAA(x8)
MERGE_IN_AGAA(x1, x2, x3, x4)  =  MERGE_IN_AGAA(x2)
MERGE_IN_GAAA(x1, x2, x3, x4)  =  MERGE_IN_GAAA(x1)
U8_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_AGAA(x8)

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
              ↳ PiDP
              ↳ PiDP
  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U8_GAAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
U6_GAAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_GAAA(.) → U8_GAAA(gt_in_aa)
MERGE_IN_AGAA(.) → U8_AGAA(gt_in_aa)
U8_AGAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
MERGE_IN_AGAA(.) → U6_AGAA(le_in_aa)
U6_AGAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_GAAA(.) → U6_GAAA(le_in_aa)

The TRS R consists of the following rules:

le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))

The set Q consists of the following terms:

le_in_aa
gt_in_aa
U11_aa(x0)
U10_aa(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule MERGE_IN_AGAA(.) → U6_AGAA(le_in_aa) at position [0] we obtained the following new rules:

MERGE_IN_AGAA(.) → U6_AGAA(U11_aa(le_in_aa))
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, 0))
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, s(0)))



↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
              ↳ PiDP
              ↳ PiDP
  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

MERGE_IN_AGAA(.) → U6_AGAA(U11_aa(le_in_aa))
U6_GAAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
U8_GAAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
MERGE_IN_GAAA(.) → U8_GAAA(gt_in_aa)
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, s(0)))
MERGE_IN_AGAA(.) → U8_AGAA(gt_in_aa)
U8_AGAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
U6_AGAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, 0))
MERGE_IN_GAAA(.) → U6_GAAA(le_in_aa)

The TRS R consists of the following rules:

le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))

The set Q consists of the following terms:

le_in_aa
gt_in_aa
U11_aa(x0)
U10_aa(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule MERGE_IN_GAAA(.) → U8_GAAA(gt_in_aa) at position [0] we obtained the following new rules:

MERGE_IN_GAAA(.) → U8_GAAA(gt_out_aa(s(0), 0))
MERGE_IN_GAAA(.) → U8_GAAA(U10_aa(gt_in_aa))



↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ Narrowing
              ↳ PiDP
              ↳ PiDP
  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

MERGE_IN_GAAA(.) → U8_GAAA(gt_out_aa(s(0), 0))
MERGE_IN_AGAA(.) → U6_AGAA(U11_aa(le_in_aa))
U8_GAAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
U6_GAAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, s(0)))
MERGE_IN_AGAA(.) → U8_AGAA(gt_in_aa)
U8_AGAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
MERGE_IN_GAAA(.) → U8_GAAA(U10_aa(gt_in_aa))
U6_AGAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_GAAA(.) → U6_GAAA(le_in_aa)
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, 0))

The TRS R consists of the following rules:

le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))

The set Q consists of the following terms:

le_in_aa
gt_in_aa
U11_aa(x0)
U10_aa(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule MERGE_IN_GAAA(.) → U6_GAAA(le_in_aa) at position [0] we obtained the following new rules:

MERGE_IN_GAAA(.) → U6_GAAA(U11_aa(le_in_aa))
MERGE_IN_GAAA(.) → U6_GAAA(le_out_aa(0, 0))
MERGE_IN_GAAA(.) → U6_GAAA(le_out_aa(0, s(0)))



↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ Narrowing
              ↳ PiDP
              ↳ PiDP
  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U6_GAAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, s(0)))
MERGE_IN_GAAA(.) → U6_GAAA(le_out_aa(0, s(0)))
U8_AGAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
U6_AGAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_GAAA(.) → U8_GAAA(gt_out_aa(s(0), 0))
MERGE_IN_AGAA(.) → U6_AGAA(U11_aa(le_in_aa))
U8_GAAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
MERGE_IN_GAAA(.) → U6_GAAA(U11_aa(le_in_aa))
MERGE_IN_AGAA(.) → U8_AGAA(gt_in_aa)
MERGE_IN_GAAA(.) → U6_GAAA(le_out_aa(0, 0))
MERGE_IN_GAAA(.) → U8_GAAA(U10_aa(gt_in_aa))
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, 0))

The TRS R consists of the following rules:

le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))

The set Q consists of the following terms:

le_in_aa
gt_in_aa
U11_aa(x0)
U10_aa(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule MERGE_IN_AGAA(.) → U8_AGAA(gt_in_aa) at position [0] we obtained the following new rules:

MERGE_IN_AGAA(.) → U8_AGAA(gt_out_aa(s(0), 0))
MERGE_IN_AGAA(.) → U8_AGAA(U10_aa(gt_in_aa))



↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ Narrowing
                                      ↳ QDP
                                        ↳ NonTerminationProof
              ↳ PiDP
              ↳ PiDP
  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U6_GAAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, s(0)))
MERGE_IN_AGAA(.) → U8_AGAA(gt_out_aa(s(0), 0))
U8_AGAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
MERGE_IN_GAAA(.) → U6_GAAA(le_out_aa(0, s(0)))
U6_AGAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_GAAA(.) → U8_GAAA(gt_out_aa(s(0), 0))
MERGE_IN_AGAA(.) → U6_AGAA(U11_aa(le_in_aa))
MERGE_IN_AGAA(.) → U8_AGAA(U10_aa(gt_in_aa))
U8_GAAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
MERGE_IN_GAAA(.) → U6_GAAA(U11_aa(le_in_aa))
MERGE_IN_GAAA(.) → U6_GAAA(le_out_aa(0, 0))
MERGE_IN_GAAA(.) → U8_GAAA(U10_aa(gt_in_aa))
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, 0))

The TRS R consists of the following rules:

le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))

The set Q consists of the following terms:

le_in_aa
gt_in_aa
U11_aa(x0)
U10_aa(x0)

We have to consider all (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by narrowing to the left:

The TRS P consists of the following rules:

U6_GAAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, s(0)))
MERGE_IN_AGAA(.) → U8_AGAA(gt_out_aa(s(0), 0))
U8_AGAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
MERGE_IN_GAAA(.) → U6_GAAA(le_out_aa(0, s(0)))
U6_AGAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_GAAA(.) → U8_GAAA(gt_out_aa(s(0), 0))
MERGE_IN_AGAA(.) → U6_AGAA(U11_aa(le_in_aa))
MERGE_IN_AGAA(.) → U8_AGAA(U10_aa(gt_in_aa))
U8_GAAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
MERGE_IN_GAAA(.) → U6_GAAA(U11_aa(le_in_aa))
MERGE_IN_GAAA(.) → U6_GAAA(le_out_aa(0, 0))
MERGE_IN_GAAA(.) → U8_GAAA(U10_aa(gt_in_aa))
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, 0))

The TRS R consists of the following rules:

le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))


s = U6_AGAA(le_out_aa(X, Y)) evaluates to t =U6_AGAA(le_out_aa(0, s(0)))

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:



Rewriting sequence

U6_AGAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
with rule U6_AGAA(le_out_aa(X', Y')) → MERGE_IN_AGAA(.) at position [] and matcher [Y' / Y, X' / X]

MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, s(0)))
with rule MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, s(0)))

Now applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence


All these steps are and every following step will be a correct step w.r.t to Q.





↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
              ↳ PiDP
  ↳ PrologToPiTRSProof

Pi DP problem:
The TRS P consists of the following rules:

SPLIT_IN_AAAA(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → SPLIT_IN_AAAA(Xs, Zs, Ys, Ls)

The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag([], [], [], Ls) → split_out_gaag([], [], [], Ls)
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(Xs, [], Xs, Ls) → merge_out_agaa(Xs, [], Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
merge_in_gaaa([], Xs, Xs, Ls) → merge_out_gaaa([], Xs, Xs, Ls)
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x2, x3)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x3)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)
SPLIT_IN_AAAA(x1, x2, x3, x4)  =  SPLIT_IN_AAAA

We have to consider all (P,R,Pi)-chains
For (infinitary) constructor rewriting [30] we can delete all non-usable rules from R.

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
              ↳ PiDP
  ↳ PrologToPiTRSProof

Pi DP problem:
The TRS P consists of the following rules:

SPLIT_IN_AAAA(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → SPLIT_IN_AAAA(Xs, Zs, Ys, Ls)

R is empty.
The argument filtering Pi contains the following mapping:
.(x1, x2)  =  .
SPLIT_IN_AAAA(x1, x2, x3, x4)  =  SPLIT_IN_AAAA

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ NonTerminationProof
              ↳ PiDP
  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

SPLIT_IN_AAAA → SPLIT_IN_AAAA

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by semiunifying a rule from P directly.

The TRS P consists of the following rules:

SPLIT_IN_AAAA → SPLIT_IN_AAAA

The TRS R consists of the following rules:none


s = SPLIT_IN_AAAA evaluates to t =SPLIT_IN_AAAA

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:



Rewriting sequence

The DP semiunifies directly so there is only one rewrite step from SPLIT_IN_AAAA to SPLIT_IN_AAAA.





↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
  ↳ PrologToPiTRSProof

Pi DP problem:
The TRS P consists of the following rules:

U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → MERGESORT_IN_GAA(X2s, Y2s, Ls)
U1_GAA(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → MERGESORT_IN_GAA(X1s, Y1s, Ls)
U1_GAA(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
MERGESORT_IN_GAA(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_GAA(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))

The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag([], [], [], Ls) → split_out_gaag([], [], [], Ls)
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(Xs, [], Xs, Ls) → merge_out_agaa(Xs, [], Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
merge_in_gaaa([], Xs, Xs, Ls) → merge_out_gaaa([], Xs, Xs, Ls)
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x2, x3)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x3)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)
U2_GAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_GAA(x7, x8)
U1_GAA(x1, x2, x3, x4, x5, x6, x7)  =  U1_GAA(x7)
MERGESORT_IN_GAA(x1, x2, x3)  =  MERGESORT_IN_GAA(x1)

We have to consider all (P,R,Pi)-chains
For (infinitary) constructor rewriting [30] we can delete all non-usable rules from R.

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
  ↳ PrologToPiTRSProof

Pi DP problem:
The TRS P consists of the following rules:

U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → MERGESORT_IN_GAA(X2s, Y2s, Ls)
U1_GAA(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → MERGESORT_IN_GAA(X1s, Y1s, Ls)
U1_GAA(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
MERGESORT_IN_GAA(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_GAA(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))

The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x2, x3)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x3)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)
U2_GAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_GAA(x7, x8)
U1_GAA(x1, x2, x3, x4, x5, x6, x7)  =  U1_GAA(x7)
MERGESORT_IN_GAA(x1, x2, x3)  =  MERGESORT_IN_GAA(x1)

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

MERGESORT_IN_GAA(.) → U1_GAA(split_in_gaag(., .))
U1_GAA(split_out_gaag(X1s, X2s)) → U2_GAA(X2s, mergesort_in_gaa(X1s))
U1_GAA(split_out_gaag(X1s, X2s)) → MERGESORT_IN_GAA(X1s)
U2_GAA(X2s, mergesort_out_gaa(Y1s)) → MERGESORT_IN_GAA(X2s)

The TRS R consists of the following rules:

mergesort_in_gaa([]) → mergesort_out_gaa([])
mergesort_in_gaa(.) → mergesort_out_gaa(.)
mergesort_in_gaa(.) → U1_gaa(split_in_gaag(., .))
split_in_gaag(., .) → U5_gaag(split_in_aaaa)
U1_gaa(split_out_gaag(X1s, X2s)) → U2_gaa(X2s, mergesort_in_gaa(X1s))
U5_gaag(split_out_aaaa(Xs, Zs, Ys)) → split_out_gaag(., Zs)
U2_gaa(X2s, mergesort_out_gaa(Y1s)) → U3_gaa(Y1s, mergesort_in_gaa(X2s))
split_in_aaaa → split_out_aaaa([], [], [])
split_in_aaaa → U5_aaaa(split_in_aaaa)
U3_gaa(Y1s, mergesort_out_gaa(Y2s)) → U4_gaa(merge_in_ggag(Y1s, Y2s, .))
U5_aaaa(split_out_aaaa(Xs, Zs, Ys)) → split_out_aaaa(., ., Zs)
U4_gaa(merge_out_ggag(Ys)) → mergesort_out_gaa(Ys)
merge_in_ggag([], Xs, Ls) → merge_out_ggag(Xs)
merge_in_ggag(Xs, [], Ls) → merge_out_ggag(Xs)
merge_in_ggag(., ., .) → U6_ggag(le_in_aa)
merge_in_ggag(., ., .) → U8_ggag(gt_in_aa)
U6_ggag(le_out_aa(X, Y)) → U7_ggag(merge_in_agaa(.))
U8_ggag(gt_out_aa(X, Y)) → U9_ggag(merge_in_gaaa(.))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
U7_ggag(merge_out_agaa) → merge_out_ggag(.)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U9_ggag(merge_out_gaaa) → merge_out_ggag(.)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa(Xs) → merge_out_agaa
merge_in_agaa(.) → U6_agaa(le_in_aa)
merge_in_agaa(.) → U8_agaa(gt_in_aa)
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs) → merge_out_gaaa
merge_in_gaaa(.) → U6_gaaa(le_in_aa)
merge_in_gaaa(.) → U8_gaaa(gt_in_aa)
U6_agaa(le_out_aa(X, Y)) → U7_agaa(merge_in_agaa(.))
U8_agaa(gt_out_aa(X, Y)) → U9_agaa(merge_in_gaaa(.))
U6_gaaa(le_out_aa(X, Y)) → U7_gaaa(merge_in_agaa(.))
U8_gaaa(gt_out_aa(X, Y)) → U9_gaaa(merge_in_gaaa(.))
U7_agaa(merge_out_agaa) → merge_out_agaa
U9_agaa(merge_out_gaaa) → merge_out_agaa
U7_gaaa(merge_out_agaa) → merge_out_gaaa
U9_gaaa(merge_out_gaaa) → merge_out_gaaa

The set Q consists of the following terms:

mergesort_in_gaa(x0)
split_in_gaag(x0, x1)
U1_gaa(x0)
U5_gaag(x0)
U2_gaa(x0, x1)
split_in_aaaa
U3_gaa(x0, x1)
U5_aaaa(x0)
U4_gaa(x0)
merge_in_ggag(x0, x1, x2)
U6_ggag(x0)
U8_ggag(x0)
le_in_aa
U7_ggag(x0)
gt_in_aa
U9_ggag(x0)
U11_aa(x0)
merge_in_agaa(x0)
U10_aa(x0)
merge_in_gaaa(x0)
U6_agaa(x0)
U8_agaa(x0)
U6_gaaa(x0)
U8_gaaa(x0)
U7_agaa(x0)
U9_agaa(x0)
U7_gaaa(x0)
U9_gaaa(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule U1_GAA(split_out_gaag(X1s, X2s)) → U2_GAA(X2s, mergesort_in_gaa(X1s)) at position [1] we obtained the following new rules:

U1_GAA(split_out_gaag(., y1)) → U2_GAA(y1, mergesort_out_gaa(.))
U1_GAA(split_out_gaag([], y1)) → U2_GAA(y1, mergesort_out_gaa([]))
U1_GAA(split_out_gaag(., y1)) → U2_GAA(y1, U1_gaa(split_in_gaag(., .)))



↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

MERGESORT_IN_GAA(.) → U1_GAA(split_in_gaag(., .))
U1_GAA(split_out_gaag([], y1)) → U2_GAA(y1, mergesort_out_gaa([]))
U1_GAA(split_out_gaag(., y1)) → U2_GAA(y1, mergesort_out_gaa(.))
U1_GAA(split_out_gaag(., y1)) → U2_GAA(y1, U1_gaa(split_in_gaag(., .)))
U2_GAA(X2s, mergesort_out_gaa(Y1s)) → MERGESORT_IN_GAA(X2s)
U1_GAA(split_out_gaag(X1s, X2s)) → MERGESORT_IN_GAA(X1s)

The TRS R consists of the following rules:

mergesort_in_gaa([]) → mergesort_out_gaa([])
mergesort_in_gaa(.) → mergesort_out_gaa(.)
mergesort_in_gaa(.) → U1_gaa(split_in_gaag(., .))
split_in_gaag(., .) → U5_gaag(split_in_aaaa)
U1_gaa(split_out_gaag(X1s, X2s)) → U2_gaa(X2s, mergesort_in_gaa(X1s))
U5_gaag(split_out_aaaa(Xs, Zs, Ys)) → split_out_gaag(., Zs)
U2_gaa(X2s, mergesort_out_gaa(Y1s)) → U3_gaa(Y1s, mergesort_in_gaa(X2s))
split_in_aaaa → split_out_aaaa([], [], [])
split_in_aaaa → U5_aaaa(split_in_aaaa)
U3_gaa(Y1s, mergesort_out_gaa(Y2s)) → U4_gaa(merge_in_ggag(Y1s, Y2s, .))
U5_aaaa(split_out_aaaa(Xs, Zs, Ys)) → split_out_aaaa(., ., Zs)
U4_gaa(merge_out_ggag(Ys)) → mergesort_out_gaa(Ys)
merge_in_ggag([], Xs, Ls) → merge_out_ggag(Xs)
merge_in_ggag(Xs, [], Ls) → merge_out_ggag(Xs)
merge_in_ggag(., ., .) → U6_ggag(le_in_aa)
merge_in_ggag(., ., .) → U8_ggag(gt_in_aa)
U6_ggag(le_out_aa(X, Y)) → U7_ggag(merge_in_agaa(.))
U8_ggag(gt_out_aa(X, Y)) → U9_ggag(merge_in_gaaa(.))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
U7_ggag(merge_out_agaa) → merge_out_ggag(.)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U9_ggag(merge_out_gaaa) → merge_out_ggag(.)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa(Xs) → merge_out_agaa
merge_in_agaa(.) → U6_agaa(le_in_aa)
merge_in_agaa(.) → U8_agaa(gt_in_aa)
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs) → merge_out_gaaa
merge_in_gaaa(.) → U6_gaaa(le_in_aa)
merge_in_gaaa(.) → U8_gaaa(gt_in_aa)
U6_agaa(le_out_aa(X, Y)) → U7_agaa(merge_in_agaa(.))
U8_agaa(gt_out_aa(X, Y)) → U9_agaa(merge_in_gaaa(.))
U6_gaaa(le_out_aa(X, Y)) → U7_gaaa(merge_in_agaa(.))
U8_gaaa(gt_out_aa(X, Y)) → U9_gaaa(merge_in_gaaa(.))
U7_agaa(merge_out_agaa) → merge_out_agaa
U9_agaa(merge_out_gaaa) → merge_out_agaa
U7_gaaa(merge_out_agaa) → merge_out_gaaa
U9_gaaa(merge_out_gaaa) → merge_out_gaaa

The set Q consists of the following terms:

mergesort_in_gaa(x0)
split_in_gaag(x0, x1)
U1_gaa(x0)
U5_gaag(x0)
U2_gaa(x0, x1)
split_in_aaaa
U3_gaa(x0, x1)
U5_aaaa(x0)
U4_gaa(x0)
merge_in_ggag(x0, x1, x2)
U6_ggag(x0)
U8_ggag(x0)
le_in_aa
U7_ggag(x0)
gt_in_aa
U9_ggag(x0)
U11_aa(x0)
merge_in_agaa(x0)
U10_aa(x0)
merge_in_gaaa(x0)
U6_agaa(x0)
U8_agaa(x0)
U6_gaaa(x0)
U8_gaaa(x0)
U7_agaa(x0)
U9_agaa(x0)
U7_gaaa(x0)
U9_gaaa(x0)

We have to consider all (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

MERGESORT_IN_GAA(.) → U1_GAA(split_in_gaag(., .))
U1_GAA(split_out_gaag(., y1)) → U2_GAA(y1, mergesort_out_gaa(.))
U1_GAA(split_out_gaag(., y1)) → U2_GAA(y1, U1_gaa(split_in_gaag(., .)))
U2_GAA(X2s, mergesort_out_gaa(Y1s)) → MERGESORT_IN_GAA(X2s)
U1_GAA(split_out_gaag(X1s, X2s)) → MERGESORT_IN_GAA(X1s)

The TRS R consists of the following rules:

mergesort_in_gaa([]) → mergesort_out_gaa([])
mergesort_in_gaa(.) → mergesort_out_gaa(.)
mergesort_in_gaa(.) → U1_gaa(split_in_gaag(., .))
split_in_gaag(., .) → U5_gaag(split_in_aaaa)
U1_gaa(split_out_gaag(X1s, X2s)) → U2_gaa(X2s, mergesort_in_gaa(X1s))
U5_gaag(split_out_aaaa(Xs, Zs, Ys)) → split_out_gaag(., Zs)
U2_gaa(X2s, mergesort_out_gaa(Y1s)) → U3_gaa(Y1s, mergesort_in_gaa(X2s))
split_in_aaaa → split_out_aaaa([], [], [])
split_in_aaaa → U5_aaaa(split_in_aaaa)
U3_gaa(Y1s, mergesort_out_gaa(Y2s)) → U4_gaa(merge_in_ggag(Y1s, Y2s, .))
U5_aaaa(split_out_aaaa(Xs, Zs, Ys)) → split_out_aaaa(., ., Zs)
U4_gaa(merge_out_ggag(Ys)) → mergesort_out_gaa(Ys)
merge_in_ggag([], Xs, Ls) → merge_out_ggag(Xs)
merge_in_ggag(Xs, [], Ls) → merge_out_ggag(Xs)
merge_in_ggag(., ., .) → U6_ggag(le_in_aa)
merge_in_ggag(., ., .) → U8_ggag(gt_in_aa)
U6_ggag(le_out_aa(X, Y)) → U7_ggag(merge_in_agaa(.))
U8_ggag(gt_out_aa(X, Y)) → U9_ggag(merge_in_gaaa(.))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
U7_ggag(merge_out_agaa) → merge_out_ggag(.)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U9_ggag(merge_out_gaaa) → merge_out_ggag(.)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa(Xs) → merge_out_agaa
merge_in_agaa(.) → U6_agaa(le_in_aa)
merge_in_agaa(.) → U8_agaa(gt_in_aa)
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs) → merge_out_gaaa
merge_in_gaaa(.) → U6_gaaa(le_in_aa)
merge_in_gaaa(.) → U8_gaaa(gt_in_aa)
U6_agaa(le_out_aa(X, Y)) → U7_agaa(merge_in_agaa(.))
U8_agaa(gt_out_aa(X, Y)) → U9_agaa(merge_in_gaaa(.))
U6_gaaa(le_out_aa(X, Y)) → U7_gaaa(merge_in_agaa(.))
U8_gaaa(gt_out_aa(X, Y)) → U9_gaaa(merge_in_gaaa(.))
U7_agaa(merge_out_agaa) → merge_out_agaa
U9_agaa(merge_out_gaaa) → merge_out_agaa
U7_gaaa(merge_out_agaa) → merge_out_gaaa
U9_gaaa(merge_out_gaaa) → merge_out_gaaa

The set Q consists of the following terms:

mergesort_in_gaa(x0)
split_in_gaag(x0, x1)
U1_gaa(x0)
U5_gaag(x0)
U2_gaa(x0, x1)
split_in_aaaa
U3_gaa(x0, x1)
U5_aaaa(x0)
U4_gaa(x0)
merge_in_ggag(x0, x1, x2)
U6_ggag(x0)
U8_ggag(x0)
le_in_aa
U7_ggag(x0)
gt_in_aa
U9_ggag(x0)
U11_aa(x0)
merge_in_agaa(x0)
U10_aa(x0)
merge_in_gaaa(x0)
U6_agaa(x0)
U8_agaa(x0)
U6_gaaa(x0)
U8_gaaa(x0)
U7_agaa(x0)
U9_agaa(x0)
U7_gaaa(x0)
U9_gaaa(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule MERGESORT_IN_GAA(.) → U1_GAA(split_in_gaag(., .)) at position [0] we obtained the following new rules:

MERGESORT_IN_GAA(.) → U1_GAA(U5_gaag(split_in_aaaa))



↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ ForwardInstantiation
  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

MERGESORT_IN_GAA(.) → U1_GAA(U5_gaag(split_in_aaaa))
U1_GAA(split_out_gaag(., y1)) → U2_GAA(y1, mergesort_out_gaa(.))
U1_GAA(split_out_gaag(., y1)) → U2_GAA(y1, U1_gaa(split_in_gaag(., .)))
U1_GAA(split_out_gaag(X1s, X2s)) → MERGESORT_IN_GAA(X1s)
U2_GAA(X2s, mergesort_out_gaa(Y1s)) → MERGESORT_IN_GAA(X2s)

The TRS R consists of the following rules:

mergesort_in_gaa([]) → mergesort_out_gaa([])
mergesort_in_gaa(.) → mergesort_out_gaa(.)
mergesort_in_gaa(.) → U1_gaa(split_in_gaag(., .))
split_in_gaag(., .) → U5_gaag(split_in_aaaa)
U1_gaa(split_out_gaag(X1s, X2s)) → U2_gaa(X2s, mergesort_in_gaa(X1s))
U5_gaag(split_out_aaaa(Xs, Zs, Ys)) → split_out_gaag(., Zs)
U2_gaa(X2s, mergesort_out_gaa(Y1s)) → U3_gaa(Y1s, mergesort_in_gaa(X2s))
split_in_aaaa → split_out_aaaa([], [], [])
split_in_aaaa → U5_aaaa(split_in_aaaa)
U3_gaa(Y1s, mergesort_out_gaa(Y2s)) → U4_gaa(merge_in_ggag(Y1s, Y2s, .))
U5_aaaa(split_out_aaaa(Xs, Zs, Ys)) → split_out_aaaa(., ., Zs)
U4_gaa(merge_out_ggag(Ys)) → mergesort_out_gaa(Ys)
merge_in_ggag([], Xs, Ls) → merge_out_ggag(Xs)
merge_in_ggag(Xs, [], Ls) → merge_out_ggag(Xs)
merge_in_ggag(., ., .) → U6_ggag(le_in_aa)
merge_in_ggag(., ., .) → U8_ggag(gt_in_aa)
U6_ggag(le_out_aa(X, Y)) → U7_ggag(merge_in_agaa(.))
U8_ggag(gt_out_aa(X, Y)) → U9_ggag(merge_in_gaaa(.))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
U7_ggag(merge_out_agaa) → merge_out_ggag(.)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U9_ggag(merge_out_gaaa) → merge_out_ggag(.)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa(Xs) → merge_out_agaa
merge_in_agaa(.) → U6_agaa(le_in_aa)
merge_in_agaa(.) → U8_agaa(gt_in_aa)
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs) → merge_out_gaaa
merge_in_gaaa(.) → U6_gaaa(le_in_aa)
merge_in_gaaa(.) → U8_gaaa(gt_in_aa)
U6_agaa(le_out_aa(X, Y)) → U7_agaa(merge_in_agaa(.))
U8_agaa(gt_out_aa(X, Y)) → U9_agaa(merge_in_gaaa(.))
U6_gaaa(le_out_aa(X, Y)) → U7_gaaa(merge_in_agaa(.))
U8_gaaa(gt_out_aa(X, Y)) → U9_gaaa(merge_in_gaaa(.))
U7_agaa(merge_out_agaa) → merge_out_agaa
U9_agaa(merge_out_gaaa) → merge_out_agaa
U7_gaaa(merge_out_agaa) → merge_out_gaaa
U9_gaaa(merge_out_gaaa) → merge_out_gaaa

The set Q consists of the following terms:

mergesort_in_gaa(x0)
split_in_gaag(x0, x1)
U1_gaa(x0)
U5_gaag(x0)
U2_gaa(x0, x1)
split_in_aaaa
U3_gaa(x0, x1)
U5_aaaa(x0)
U4_gaa(x0)
merge_in_ggag(x0, x1, x2)
U6_ggag(x0)
U8_ggag(x0)
le_in_aa
U7_ggag(x0)
gt_in_aa
U9_ggag(x0)
U11_aa(x0)
merge_in_agaa(x0)
U10_aa(x0)
merge_in_gaaa(x0)
U6_agaa(x0)
U8_agaa(x0)
U6_gaaa(x0)
U8_gaaa(x0)
U7_agaa(x0)
U9_agaa(x0)
U7_gaaa(x0)
U9_gaaa(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule U1_GAA(split_out_gaag(X1s, X2s)) → MERGESORT_IN_GAA(X1s) we obtained the following new rules:

U1_GAA(split_out_gaag(., x1)) → MERGESORT_IN_GAA(.)



↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ ForwardInstantiation
                                      ↳ QDP
                                        ↳ ForwardInstantiation
  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U1_GAA(split_out_gaag(., x1)) → MERGESORT_IN_GAA(.)
MERGESORT_IN_GAA(.) → U1_GAA(U5_gaag(split_in_aaaa))
U1_GAA(split_out_gaag(., y1)) → U2_GAA(y1, mergesort_out_gaa(.))
U1_GAA(split_out_gaag(., y1)) → U2_GAA(y1, U1_gaa(split_in_gaag(., .)))
U2_GAA(X2s, mergesort_out_gaa(Y1s)) → MERGESORT_IN_GAA(X2s)

The TRS R consists of the following rules:

mergesort_in_gaa([]) → mergesort_out_gaa([])
mergesort_in_gaa(.) → mergesort_out_gaa(.)
mergesort_in_gaa(.) → U1_gaa(split_in_gaag(., .))
split_in_gaag(., .) → U5_gaag(split_in_aaaa)
U1_gaa(split_out_gaag(X1s, X2s)) → U2_gaa(X2s, mergesort_in_gaa(X1s))
U5_gaag(split_out_aaaa(Xs, Zs, Ys)) → split_out_gaag(., Zs)
U2_gaa(X2s, mergesort_out_gaa(Y1s)) → U3_gaa(Y1s, mergesort_in_gaa(X2s))
split_in_aaaa → split_out_aaaa([], [], [])
split_in_aaaa → U5_aaaa(split_in_aaaa)
U3_gaa(Y1s, mergesort_out_gaa(Y2s)) → U4_gaa(merge_in_ggag(Y1s, Y2s, .))
U5_aaaa(split_out_aaaa(Xs, Zs, Ys)) → split_out_aaaa(., ., Zs)
U4_gaa(merge_out_ggag(Ys)) → mergesort_out_gaa(Ys)
merge_in_ggag([], Xs, Ls) → merge_out_ggag(Xs)
merge_in_ggag(Xs, [], Ls) → merge_out_ggag(Xs)
merge_in_ggag(., ., .) → U6_ggag(le_in_aa)
merge_in_ggag(., ., .) → U8_ggag(gt_in_aa)
U6_ggag(le_out_aa(X, Y)) → U7_ggag(merge_in_agaa(.))
U8_ggag(gt_out_aa(X, Y)) → U9_ggag(merge_in_gaaa(.))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
U7_ggag(merge_out_agaa) → merge_out_ggag(.)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U9_ggag(merge_out_gaaa) → merge_out_ggag(.)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa(Xs) → merge_out_agaa
merge_in_agaa(.) → U6_agaa(le_in_aa)
merge_in_agaa(.) → U8_agaa(gt_in_aa)
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs) → merge_out_gaaa
merge_in_gaaa(.) → U6_gaaa(le_in_aa)
merge_in_gaaa(.) → U8_gaaa(gt_in_aa)
U6_agaa(le_out_aa(X, Y)) → U7_agaa(merge_in_agaa(.))
U8_agaa(gt_out_aa(X, Y)) → U9_agaa(merge_in_gaaa(.))
U6_gaaa(le_out_aa(X, Y)) → U7_gaaa(merge_in_agaa(.))
U8_gaaa(gt_out_aa(X, Y)) → U9_gaaa(merge_in_gaaa(.))
U7_agaa(merge_out_agaa) → merge_out_agaa
U9_agaa(merge_out_gaaa) → merge_out_agaa
U7_gaaa(merge_out_agaa) → merge_out_gaaa
U9_gaaa(merge_out_gaaa) → merge_out_gaaa

The set Q consists of the following terms:

mergesort_in_gaa(x0)
split_in_gaag(x0, x1)
U1_gaa(x0)
U5_gaag(x0)
U2_gaa(x0, x1)
split_in_aaaa
U3_gaa(x0, x1)
U5_aaaa(x0)
U4_gaa(x0)
merge_in_ggag(x0, x1, x2)
U6_ggag(x0)
U8_ggag(x0)
le_in_aa
U7_ggag(x0)
gt_in_aa
U9_ggag(x0)
U11_aa(x0)
merge_in_agaa(x0)
U10_aa(x0)
merge_in_gaaa(x0)
U6_agaa(x0)
U8_agaa(x0)
U6_gaaa(x0)
U8_gaaa(x0)
U7_agaa(x0)
U9_agaa(x0)
U7_gaaa(x0)
U9_gaaa(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule U2_GAA(X2s, mergesort_out_gaa(Y1s)) → MERGESORT_IN_GAA(X2s) we obtained the following new rules:

U2_GAA(., mergesort_out_gaa(x1)) → MERGESORT_IN_GAA(.)



↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ ForwardInstantiation
                                      ↳ QDP
                                        ↳ ForwardInstantiation
                                          ↳ QDP
                                            ↳ ForwardInstantiation
  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

MERGESORT_IN_GAA(.) → U1_GAA(U5_gaag(split_in_aaaa))
U1_GAA(split_out_gaag(., x1)) → MERGESORT_IN_GAA(.)
U1_GAA(split_out_gaag(., y1)) → U2_GAA(y1, mergesort_out_gaa(.))
U1_GAA(split_out_gaag(., y1)) → U2_GAA(y1, U1_gaa(split_in_gaag(., .)))
U2_GAA(., mergesort_out_gaa(x1)) → MERGESORT_IN_GAA(.)

The TRS R consists of the following rules:

mergesort_in_gaa([]) → mergesort_out_gaa([])
mergesort_in_gaa(.) → mergesort_out_gaa(.)
mergesort_in_gaa(.) → U1_gaa(split_in_gaag(., .))
split_in_gaag(., .) → U5_gaag(split_in_aaaa)
U1_gaa(split_out_gaag(X1s, X2s)) → U2_gaa(X2s, mergesort_in_gaa(X1s))
U5_gaag(split_out_aaaa(Xs, Zs, Ys)) → split_out_gaag(., Zs)
U2_gaa(X2s, mergesort_out_gaa(Y1s)) → U3_gaa(Y1s, mergesort_in_gaa(X2s))
split_in_aaaa → split_out_aaaa([], [], [])
split_in_aaaa → U5_aaaa(split_in_aaaa)
U3_gaa(Y1s, mergesort_out_gaa(Y2s)) → U4_gaa(merge_in_ggag(Y1s, Y2s, .))
U5_aaaa(split_out_aaaa(Xs, Zs, Ys)) → split_out_aaaa(., ., Zs)
U4_gaa(merge_out_ggag(Ys)) → mergesort_out_gaa(Ys)
merge_in_ggag([], Xs, Ls) → merge_out_ggag(Xs)
merge_in_ggag(Xs, [], Ls) → merge_out_ggag(Xs)
merge_in_ggag(., ., .) → U6_ggag(le_in_aa)
merge_in_ggag(., ., .) → U8_ggag(gt_in_aa)
U6_ggag(le_out_aa(X, Y)) → U7_ggag(merge_in_agaa(.))
U8_ggag(gt_out_aa(X, Y)) → U9_ggag(merge_in_gaaa(.))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
U7_ggag(merge_out_agaa) → merge_out_ggag(.)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U9_ggag(merge_out_gaaa) → merge_out_ggag(.)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa(Xs) → merge_out_agaa
merge_in_agaa(.) → U6_agaa(le_in_aa)
merge_in_agaa(.) → U8_agaa(gt_in_aa)
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs) → merge_out_gaaa
merge_in_gaaa(.) → U6_gaaa(le_in_aa)
merge_in_gaaa(.) → U8_gaaa(gt_in_aa)
U6_agaa(le_out_aa(X, Y)) → U7_agaa(merge_in_agaa(.))
U8_agaa(gt_out_aa(X, Y)) → U9_agaa(merge_in_gaaa(.))
U6_gaaa(le_out_aa(X, Y)) → U7_gaaa(merge_in_agaa(.))
U8_gaaa(gt_out_aa(X, Y)) → U9_gaaa(merge_in_gaaa(.))
U7_agaa(merge_out_agaa) → merge_out_agaa
U9_agaa(merge_out_gaaa) → merge_out_agaa
U7_gaaa(merge_out_agaa) → merge_out_gaaa
U9_gaaa(merge_out_gaaa) → merge_out_gaaa

The set Q consists of the following terms:

mergesort_in_gaa(x0)
split_in_gaag(x0, x1)
U1_gaa(x0)
U5_gaag(x0)
U2_gaa(x0, x1)
split_in_aaaa
U3_gaa(x0, x1)
U5_aaaa(x0)
U4_gaa(x0)
merge_in_ggag(x0, x1, x2)
U6_ggag(x0)
U8_ggag(x0)
le_in_aa
U7_ggag(x0)
gt_in_aa
U9_ggag(x0)
U11_aa(x0)
merge_in_agaa(x0)
U10_aa(x0)
merge_in_gaaa(x0)
U6_agaa(x0)
U8_agaa(x0)
U6_gaaa(x0)
U8_gaaa(x0)
U7_agaa(x0)
U9_agaa(x0)
U7_gaaa(x0)
U9_gaaa(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule U1_GAA(split_out_gaag(., y1)) → U2_GAA(y1, mergesort_out_gaa(.)) we obtained the following new rules:

U1_GAA(split_out_gaag(., .)) → U2_GAA(., mergesort_out_gaa(.))



↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ ForwardInstantiation
                                      ↳ QDP
                                        ↳ ForwardInstantiation
                                          ↳ QDP
                                            ↳ ForwardInstantiation
                                              ↳ QDP
                                                ↳ ForwardInstantiation
  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

U1_GAA(split_out_gaag(., x1)) → MERGESORT_IN_GAA(.)
MERGESORT_IN_GAA(.) → U1_GAA(U5_gaag(split_in_aaaa))
U1_GAA(split_out_gaag(., y1)) → U2_GAA(y1, U1_gaa(split_in_gaag(., .)))
U2_GAA(., mergesort_out_gaa(x1)) → MERGESORT_IN_GAA(.)
U1_GAA(split_out_gaag(., .)) → U2_GAA(., mergesort_out_gaa(.))

The TRS R consists of the following rules:

mergesort_in_gaa([]) → mergesort_out_gaa([])
mergesort_in_gaa(.) → mergesort_out_gaa(.)
mergesort_in_gaa(.) → U1_gaa(split_in_gaag(., .))
split_in_gaag(., .) → U5_gaag(split_in_aaaa)
U1_gaa(split_out_gaag(X1s, X2s)) → U2_gaa(X2s, mergesort_in_gaa(X1s))
U5_gaag(split_out_aaaa(Xs, Zs, Ys)) → split_out_gaag(., Zs)
U2_gaa(X2s, mergesort_out_gaa(Y1s)) → U3_gaa(Y1s, mergesort_in_gaa(X2s))
split_in_aaaa → split_out_aaaa([], [], [])
split_in_aaaa → U5_aaaa(split_in_aaaa)
U3_gaa(Y1s, mergesort_out_gaa(Y2s)) → U4_gaa(merge_in_ggag(Y1s, Y2s, .))
U5_aaaa(split_out_aaaa(Xs, Zs, Ys)) → split_out_aaaa(., ., Zs)
U4_gaa(merge_out_ggag(Ys)) → mergesort_out_gaa(Ys)
merge_in_ggag([], Xs, Ls) → merge_out_ggag(Xs)
merge_in_ggag(Xs, [], Ls) → merge_out_ggag(Xs)
merge_in_ggag(., ., .) → U6_ggag(le_in_aa)
merge_in_ggag(., ., .) → U8_ggag(gt_in_aa)
U6_ggag(le_out_aa(X, Y)) → U7_ggag(merge_in_agaa(.))
U8_ggag(gt_out_aa(X, Y)) → U9_ggag(merge_in_gaaa(.))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
U7_ggag(merge_out_agaa) → merge_out_ggag(.)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U9_ggag(merge_out_gaaa) → merge_out_ggag(.)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa(Xs) → merge_out_agaa
merge_in_agaa(.) → U6_agaa(le_in_aa)
merge_in_agaa(.) → U8_agaa(gt_in_aa)
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs) → merge_out_gaaa
merge_in_gaaa(.) → U6_gaaa(le_in_aa)
merge_in_gaaa(.) → U8_gaaa(gt_in_aa)
U6_agaa(le_out_aa(X, Y)) → U7_agaa(merge_in_agaa(.))
U8_agaa(gt_out_aa(X, Y)) → U9_agaa(merge_in_gaaa(.))
U6_gaaa(le_out_aa(X, Y)) → U7_gaaa(merge_in_agaa(.))
U8_gaaa(gt_out_aa(X, Y)) → U9_gaaa(merge_in_gaaa(.))
U7_agaa(merge_out_agaa) → merge_out_agaa
U9_agaa(merge_out_gaaa) → merge_out_agaa
U7_gaaa(merge_out_agaa) → merge_out_gaaa
U9_gaaa(merge_out_gaaa) → merge_out_gaaa

The set Q consists of the following terms:

mergesort_in_gaa(x0)
split_in_gaag(x0, x1)
U1_gaa(x0)
U5_gaag(x0)
U2_gaa(x0, x1)
split_in_aaaa
U3_gaa(x0, x1)
U5_aaaa(x0)
U4_gaa(x0)
merge_in_ggag(x0, x1, x2)
U6_ggag(x0)
U8_ggag(x0)
le_in_aa
U7_ggag(x0)
gt_in_aa
U9_ggag(x0)
U11_aa(x0)
merge_in_agaa(x0)
U10_aa(x0)
merge_in_gaaa(x0)
U6_agaa(x0)
U8_agaa(x0)
U6_gaaa(x0)
U8_gaaa(x0)
U7_agaa(x0)
U9_agaa(x0)
U7_gaaa(x0)
U9_gaaa(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule U1_GAA(split_out_gaag(., y1)) → U2_GAA(y1, U1_gaa(split_in_gaag(., .))) we obtained the following new rules:

U1_GAA(split_out_gaag(., .)) → U2_GAA(., U1_gaa(split_in_gaag(., .)))



↳ Prolog
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ ForwardInstantiation
                                      ↳ QDP
                                        ↳ ForwardInstantiation
                                          ↳ QDP
                                            ↳ ForwardInstantiation
                                              ↳ QDP
                                                ↳ ForwardInstantiation
                                                  ↳ QDP
                                                    ↳ NonTerminationProof
  ↳ PrologToPiTRSProof

Q DP problem:
The TRS P consists of the following rules:

MERGESORT_IN_GAA(.) → U1_GAA(U5_gaag(split_in_aaaa))
U1_GAA(split_out_gaag(., x1)) → MERGESORT_IN_GAA(.)
U1_GAA(split_out_gaag(., .)) → U2_GAA(., U1_gaa(split_in_gaag(., .)))
U2_GAA(., mergesort_out_gaa(x1)) → MERGESORT_IN_GAA(.)
U1_GAA(split_out_gaag(., .)) → U2_GAA(., mergesort_out_gaa(.))

The TRS R consists of the following rules:

mergesort_in_gaa([]) → mergesort_out_gaa([])
mergesort_in_gaa(.) → mergesort_out_gaa(.)
mergesort_in_gaa(.) → U1_gaa(split_in_gaag(., .))
split_in_gaag(., .) → U5_gaag(split_in_aaaa)
U1_gaa(split_out_gaag(X1s, X2s)) → U2_gaa(X2s, mergesort_in_gaa(X1s))
U5_gaag(split_out_aaaa(Xs, Zs, Ys)) → split_out_gaag(., Zs)
U2_gaa(X2s, mergesort_out_gaa(Y1s)) → U3_gaa(Y1s, mergesort_in_gaa(X2s))
split_in_aaaa → split_out_aaaa([], [], [])
split_in_aaaa → U5_aaaa(split_in_aaaa)
U3_gaa(Y1s, mergesort_out_gaa(Y2s)) → U4_gaa(merge_in_ggag(Y1s, Y2s, .))
U5_aaaa(split_out_aaaa(Xs, Zs, Ys)) → split_out_aaaa(., ., Zs)
U4_gaa(merge_out_ggag(Ys)) → mergesort_out_gaa(Ys)
merge_in_ggag([], Xs, Ls) → merge_out_ggag(Xs)
merge_in_ggag(Xs, [], Ls) → merge_out_ggag(Xs)
merge_in_ggag(., ., .) → U6_ggag(le_in_aa)
merge_in_ggag(., ., .) → U8_ggag(gt_in_aa)
U6_ggag(le_out_aa(X, Y)) → U7_ggag(merge_in_agaa(.))
U8_ggag(gt_out_aa(X, Y)) → U9_ggag(merge_in_gaaa(.))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
U7_ggag(merge_out_agaa) → merge_out_ggag(.)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U9_ggag(merge_out_gaaa) → merge_out_ggag(.)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa(Xs) → merge_out_agaa
merge_in_agaa(.) → U6_agaa(le_in_aa)
merge_in_agaa(.) → U8_agaa(gt_in_aa)
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs) → merge_out_gaaa
merge_in_gaaa(.) → U6_gaaa(le_in_aa)
merge_in_gaaa(.) → U8_gaaa(gt_in_aa)
U6_agaa(le_out_aa(X, Y)) → U7_agaa(merge_in_agaa(.))
U8_agaa(gt_out_aa(X, Y)) → U9_agaa(merge_in_gaaa(.))
U6_gaaa(le_out_aa(X, Y)) → U7_gaaa(merge_in_agaa(.))
U8_gaaa(gt_out_aa(X, Y)) → U9_gaaa(merge_in_gaaa(.))
U7_agaa(merge_out_agaa) → merge_out_agaa
U9_agaa(merge_out_gaaa) → merge_out_agaa
U7_gaaa(merge_out_agaa) → merge_out_gaaa
U9_gaaa(merge_out_gaaa) → merge_out_gaaa

The set Q consists of the following terms:

mergesort_in_gaa(x0)
split_in_gaag(x0, x1)
U1_gaa(x0)
U5_gaag(x0)
U2_gaa(x0, x1)
split_in_aaaa
U3_gaa(x0, x1)
U5_aaaa(x0)
U4_gaa(x0)
merge_in_ggag(x0, x1, x2)
U6_ggag(x0)
U8_ggag(x0)
le_in_aa
U7_ggag(x0)
gt_in_aa
U9_ggag(x0)
U11_aa(x0)
merge_in_agaa(x0)
U10_aa(x0)
merge_in_gaaa(x0)
U6_agaa(x0)
U8_agaa(x0)
U6_gaaa(x0)
U8_gaaa(x0)
U7_agaa(x0)
U9_agaa(x0)
U7_gaaa(x0)
U9_gaaa(x0)

We have to consider all (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by narrowing to the left:

The TRS P consists of the following rules:

MERGESORT_IN_GAA(.) → U1_GAA(U5_gaag(split_in_aaaa))
U1_GAA(split_out_gaag(., x1)) → MERGESORT_IN_GAA(.)
U1_GAA(split_out_gaag(., .)) → U2_GAA(., U1_gaa(split_in_gaag(., .)))
U2_GAA(., mergesort_out_gaa(x1)) → MERGESORT_IN_GAA(.)
U1_GAA(split_out_gaag(., .)) → U2_GAA(., mergesort_out_gaa(.))

The TRS R consists of the following rules:

mergesort_in_gaa([]) → mergesort_out_gaa([])
mergesort_in_gaa(.) → mergesort_out_gaa(.)
mergesort_in_gaa(.) → U1_gaa(split_in_gaag(., .))
split_in_gaag(., .) → U5_gaag(split_in_aaaa)
U1_gaa(split_out_gaag(X1s, X2s)) → U2_gaa(X2s, mergesort_in_gaa(X1s))
U5_gaag(split_out_aaaa(Xs, Zs, Ys)) → split_out_gaag(., Zs)
U2_gaa(X2s, mergesort_out_gaa(Y1s)) → U3_gaa(Y1s, mergesort_in_gaa(X2s))
split_in_aaaa → split_out_aaaa([], [], [])
split_in_aaaa → U5_aaaa(split_in_aaaa)
U3_gaa(Y1s, mergesort_out_gaa(Y2s)) → U4_gaa(merge_in_ggag(Y1s, Y2s, .))
U5_aaaa(split_out_aaaa(Xs, Zs, Ys)) → split_out_aaaa(., ., Zs)
U4_gaa(merge_out_ggag(Ys)) → mergesort_out_gaa(Ys)
merge_in_ggag([], Xs, Ls) → merge_out_ggag(Xs)
merge_in_ggag(Xs, [], Ls) → merge_out_ggag(Xs)
merge_in_ggag(., ., .) → U6_ggag(le_in_aa)
merge_in_ggag(., ., .) → U8_ggag(gt_in_aa)
U6_ggag(le_out_aa(X, Y)) → U7_ggag(merge_in_agaa(.))
U8_ggag(gt_out_aa(X, Y)) → U9_ggag(merge_in_gaaa(.))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
U7_ggag(merge_out_agaa) → merge_out_ggag(.)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U9_ggag(merge_out_gaaa) → merge_out_ggag(.)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa(Xs) → merge_out_agaa
merge_in_agaa(.) → U6_agaa(le_in_aa)
merge_in_agaa(.) → U8_agaa(gt_in_aa)
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs) → merge_out_gaaa
merge_in_gaaa(.) → U6_gaaa(le_in_aa)
merge_in_gaaa(.) → U8_gaaa(gt_in_aa)
U6_agaa(le_out_aa(X, Y)) → U7_agaa(merge_in_agaa(.))
U8_agaa(gt_out_aa(X, Y)) → U9_agaa(merge_in_gaaa(.))
U6_gaaa(le_out_aa(X, Y)) → U7_gaaa(merge_in_agaa(.))
U8_gaaa(gt_out_aa(X, Y)) → U9_gaaa(merge_in_gaaa(.))
U7_agaa(merge_out_agaa) → merge_out_agaa
U9_agaa(merge_out_gaaa) → merge_out_agaa
U7_gaaa(merge_out_agaa) → merge_out_gaaa
U9_gaaa(merge_out_gaaa) → merge_out_gaaa


s = U1_GAA(U5_gaag(split_in_aaaa)) evaluates to t =U1_GAA(U5_gaag(split_in_aaaa))

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:



Rewriting sequence

U1_GAA(U5_gaag(split_in_aaaa)) → U1_GAA(U5_gaag(split_out_aaaa([], [], [])))
with rule split_in_aaaa → split_out_aaaa([], [], []) at position [0,0] and matcher [ ]

U1_GAA(U5_gaag(split_out_aaaa([], [], []))) → U1_GAA(split_out_gaag(., []))
with rule U5_gaag(split_out_aaaa(Xs, Zs, Ys)) → split_out_gaag(., Zs) at position [0] and matcher [Xs / [], Ys / [], Zs / []]

U1_GAA(split_out_gaag(., [])) → MERGESORT_IN_GAA(.)
with rule U1_GAA(split_out_gaag(., x1)) → MERGESORT_IN_GAA(.) at position [] and matcher [x1 / []]

MERGESORT_IN_GAA(.) → U1_GAA(U5_gaag(split_in_aaaa))
with rule MERGESORT_IN_GAA(.) → U1_GAA(U5_gaag(split_in_aaaa))

Now applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence


All these steps are and every following step will be a correct step w.r.t to Q.




We use the technique of [30]. With regard to the inferred argument filtering the predicates were used in the following modes:
mergesort_in: (b,f,f)
split_in: (b,f,f,b) (f,f,f,f)
merge_in: (b,b,f,b) (f,b,f,f) (b,f,f,f)
le_in: (f,f)
gt_in: (f,f)
Transforming Prolog into the following Term Rewriting System:
Pi-finite rewrite system:
The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag([], [], [], Ls) → split_out_gaag([], [], [], Ls)
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(Xs, [], Xs, Ls) → merge_out_agaa(Xs, [], Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
merge_in_gaaa([], Xs, Xs, Ls) → merge_out_gaaa([], Xs, Xs, Ls)
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x1, x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x1, x2, x3, x4)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x1, x2, x3, x4)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa(x2)
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa(x1)
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)

Infinitary Constructor Rewriting Termination of PiTRS implies Termination of Prolog



↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof

Pi-finite rewrite system:
The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag([], [], [], Ls) → split_out_gaag([], [], [], Ls)
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(Xs, [], Xs, Ls) → merge_out_agaa(Xs, [], Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
merge_in_gaaa([], Xs, Xs, Ls) → merge_out_gaaa([], Xs, Xs, Ls)
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x1, x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x1, x2, x3, x4)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x1, x2, x3, x4)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa(x2)
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa(x1)
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)


Using Dependency Pairs [1,30] we result in the following initial DP problem:
Pi DP problem:
The TRS P consists of the following rules:

MERGESORT_IN_GAA(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_GAA(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
MERGESORT_IN_GAA(.(X, .(Y, Xs)), Ys, .(H, Ls)) → SPLIT_IN_GAAG(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))
SPLIT_IN_GAAG(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_GAAG(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
SPLIT_IN_GAAG(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → SPLIT_IN_AAAA(Xs, Zs, Ys, Ls)
SPLIT_IN_AAAA(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_AAAA(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
SPLIT_IN_AAAA(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → SPLIT_IN_AAAA(Xs, Zs, Ys, Ls)
U1_GAA(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U1_GAA(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → MERGESORT_IN_GAA(X1s, Y1s, Ls)
U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_GAA(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → MERGESORT_IN_GAA(X2s, Y2s, Ls)
U3_GAA(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_GAA(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
U3_GAA(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → MERGE_IN_GGAG(Y1s, Y2s, Ys, .(H, Ls))
MERGE_IN_GGAG(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_GGAG(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
MERGE_IN_GGAG(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → LE_IN_AA(X, Y)
LE_IN_AA(s(X), s(Y)) → U11_AA(X, Y, le_in_aa(X, Y))
LE_IN_AA(s(X), s(Y)) → LE_IN_AA(X, Y)
U6_GGAG(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_GGAG(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U6_GGAG(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → LE_IN_AA(X, Y)
U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_AGAA(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → GT_IN_AA(X, Y)
GT_IN_AA(s(X), s(Y)) → U10_AA(X, Y, gt_in_aa(X, Y))
GT_IN_AA(s(X), s(Y)) → GT_IN_AA(X, Y)
U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_AGAA(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → LE_IN_AA(X, Y)
U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_GAAA(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → GT_IN_AA(X, Y)
U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_GAAA(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)
MERGE_IN_GGAG(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_GGAG(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
MERGE_IN_GGAG(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → GT_IN_AA(X, Y)
U8_GGAG(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_GGAG(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U8_GGAG(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)

The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag([], [], [], Ls) → split_out_gaag([], [], [], Ls)
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(Xs, [], Xs, Ls) → merge_out_agaa(Xs, [], Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
merge_in_gaaa([], Xs, Xs, Ls) → merge_out_gaaa([], Xs, Xs, Ls)
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x1, x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x1, x2, x3, x4)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x1, x2, x3, x4)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa(x2)
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa(x1)
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)
U8_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GAAA(x8)
U10_AA(x1, x2, x3)  =  U10_AA(x3)
U2_GAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_GAA(x7, x8)
U9_GGAG(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_GGAG(x8)
U1_GAA(x1, x2, x3, x4, x5, x6, x7)  =  U1_GAA(x7)
LE_IN_AA(x1, x2)  =  LE_IN_AA
U5_GAAG(x1, x2, x3, x4, x5, x6, x7)  =  U5_GAAG(x7)
U6_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_AGAA(x8)
U6_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_GAAA(x8)
U6_GGAG(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_GGAG(x8)
MERGESORT_IN_GAA(x1, x2, x3)  =  MERGESORT_IN_GAA(x1)
U9_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_AGAA(x8)
MERGE_IN_AGAA(x1, x2, x3, x4)  =  MERGE_IN_AGAA(x2)
U7_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GAAA(x8)
SPLIT_IN_GAAG(x1, x2, x3, x4)  =  SPLIT_IN_GAAG(x1, x4)
U7_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_AGAA(x8)
SPLIT_IN_AAAA(x1, x2, x3, x4)  =  SPLIT_IN_AAAA
MERGE_IN_GAAA(x1, x2, x3, x4)  =  MERGE_IN_GAAA(x1)
U7_GGAG(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GGAG(x8)
U3_GAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_GAA(x7, x8)
U8_GGAG(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GGAG(x8)
U8_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_AGAA(x8)
U5_AAAA(x1, x2, x3, x4, x5, x6, x7)  =  U5_AAAA(x7)
GT_IN_AA(x1, x2)  =  GT_IN_AA
MERGE_IN_GGAG(x1, x2, x3, x4)  =  MERGE_IN_GGAG(x1, x2, x4)
U9_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_GAAA(x8)
U11_AA(x1, x2, x3)  =  U11_AA(x3)
U4_GAA(x1, x2, x3, x4, x5, x6, x7)  =  U4_GAA(x7)

We have to consider all (P,R,Pi)-chains

↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof

Pi DP problem:
The TRS P consists of the following rules:

MERGESORT_IN_GAA(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_GAA(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
MERGESORT_IN_GAA(.(X, .(Y, Xs)), Ys, .(H, Ls)) → SPLIT_IN_GAAG(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))
SPLIT_IN_GAAG(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_GAAG(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
SPLIT_IN_GAAG(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → SPLIT_IN_AAAA(Xs, Zs, Ys, Ls)
SPLIT_IN_AAAA(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_AAAA(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
SPLIT_IN_AAAA(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → SPLIT_IN_AAAA(Xs, Zs, Ys, Ls)
U1_GAA(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U1_GAA(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → MERGESORT_IN_GAA(X1s, Y1s, Ls)
U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_GAA(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → MERGESORT_IN_GAA(X2s, Y2s, Ls)
U3_GAA(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_GAA(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
U3_GAA(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → MERGE_IN_GGAG(Y1s, Y2s, Ys, .(H, Ls))
MERGE_IN_GGAG(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_GGAG(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
MERGE_IN_GGAG(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → LE_IN_AA(X, Y)
LE_IN_AA(s(X), s(Y)) → U11_AA(X, Y, le_in_aa(X, Y))
LE_IN_AA(s(X), s(Y)) → LE_IN_AA(X, Y)
U6_GGAG(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_GGAG(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U6_GGAG(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → LE_IN_AA(X, Y)
U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_AGAA(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → GT_IN_AA(X, Y)
GT_IN_AA(s(X), s(Y)) → U10_AA(X, Y, gt_in_aa(X, Y))
GT_IN_AA(s(X), s(Y)) → GT_IN_AA(X, Y)
U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_AGAA(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → LE_IN_AA(X, Y)
U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_GAAA(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → GT_IN_AA(X, Y)
U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_GAAA(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)
MERGE_IN_GGAG(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_GGAG(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
MERGE_IN_GGAG(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → GT_IN_AA(X, Y)
U8_GGAG(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_GGAG(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U8_GGAG(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)

The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag([], [], [], Ls) → split_out_gaag([], [], [], Ls)
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(Xs, [], Xs, Ls) → merge_out_agaa(Xs, [], Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
merge_in_gaaa([], Xs, Xs, Ls) → merge_out_gaaa([], Xs, Xs, Ls)
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x1, x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x1, x2, x3, x4)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x1, x2, x3, x4)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa(x2)
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa(x1)
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)
U8_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GAAA(x8)
U10_AA(x1, x2, x3)  =  U10_AA(x3)
U2_GAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_GAA(x7, x8)
U9_GGAG(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_GGAG(x8)
U1_GAA(x1, x2, x3, x4, x5, x6, x7)  =  U1_GAA(x7)
LE_IN_AA(x1, x2)  =  LE_IN_AA
U5_GAAG(x1, x2, x3, x4, x5, x6, x7)  =  U5_GAAG(x7)
U6_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_AGAA(x8)
U6_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_GAAA(x8)
U6_GGAG(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_GGAG(x8)
MERGESORT_IN_GAA(x1, x2, x3)  =  MERGESORT_IN_GAA(x1)
U9_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_AGAA(x8)
MERGE_IN_AGAA(x1, x2, x3, x4)  =  MERGE_IN_AGAA(x2)
U7_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GAAA(x8)
SPLIT_IN_GAAG(x1, x2, x3, x4)  =  SPLIT_IN_GAAG(x1, x4)
U7_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_AGAA(x8)
SPLIT_IN_AAAA(x1, x2, x3, x4)  =  SPLIT_IN_AAAA
MERGE_IN_GAAA(x1, x2, x3, x4)  =  MERGE_IN_GAAA(x1)
U7_GGAG(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_GGAG(x8)
U3_GAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_GAA(x7, x8)
U8_GGAG(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GGAG(x8)
U8_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_AGAA(x8)
U5_AAAA(x1, x2, x3, x4, x5, x6, x7)  =  U5_AAAA(x7)
GT_IN_AA(x1, x2)  =  GT_IN_AA
MERGE_IN_GGAG(x1, x2, x3, x4)  =  MERGE_IN_GGAG(x1, x2, x4)
U9_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_GAAA(x8)
U11_AA(x1, x2, x3)  =  U11_AA(x3)
U4_GAA(x1, x2, x3, x4, x5, x6, x7)  =  U4_GAA(x7)

We have to consider all (P,R,Pi)-chains
The approximation of the Dependency Graph [30] contains 5 SCCs with 25 less nodes.

↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
                ↳ UsableRulesProof
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP

Pi DP problem:
The TRS P consists of the following rules:

GT_IN_AA(s(X), s(Y)) → GT_IN_AA(X, Y)

The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag([], [], [], Ls) → split_out_gaag([], [], [], Ls)
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(Xs, [], Xs, Ls) → merge_out_agaa(Xs, [], Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
merge_in_gaaa([], Xs, Xs, Ls) → merge_out_gaaa([], Xs, Xs, Ls)
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x1, x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x1, x2, x3, x4)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x1, x2, x3, x4)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa(x2)
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa(x1)
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)
GT_IN_AA(x1, x2)  =  GT_IN_AA

We have to consider all (P,R,Pi)-chains
For (infinitary) constructor rewriting [30] we can delete all non-usable rules from R.

↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP

Pi DP problem:
The TRS P consists of the following rules:

GT_IN_AA(s(X), s(Y)) → GT_IN_AA(X, Y)

R is empty.
The argument filtering Pi contains the following mapping:
s(x1)  =  s(x1)
GT_IN_AA(x1, x2)  =  GT_IN_AA

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ NonTerminationProof
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP

Q DP problem:
The TRS P consists of the following rules:

GT_IN_AA → GT_IN_AA

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by semiunifying a rule from P directly.

The TRS P consists of the following rules:

GT_IN_AA → GT_IN_AA

The TRS R consists of the following rules:none


s = GT_IN_AA evaluates to t =GT_IN_AA

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:



Rewriting sequence

The DP semiunifies directly so there is only one rewrite step from GT_IN_AA to GT_IN_AA.





↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP

Pi DP problem:
The TRS P consists of the following rules:

LE_IN_AA(s(X), s(Y)) → LE_IN_AA(X, Y)

The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag([], [], [], Ls) → split_out_gaag([], [], [], Ls)
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(Xs, [], Xs, Ls) → merge_out_agaa(Xs, [], Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
merge_in_gaaa([], Xs, Xs, Ls) → merge_out_gaaa([], Xs, Xs, Ls)
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x1, x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x1, x2, x3, x4)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x1, x2, x3, x4)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa(x2)
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa(x1)
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)
LE_IN_AA(x1, x2)  =  LE_IN_AA

We have to consider all (P,R,Pi)-chains
For (infinitary) constructor rewriting [30] we can delete all non-usable rules from R.

↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP

Pi DP problem:
The TRS P consists of the following rules:

LE_IN_AA(s(X), s(Y)) → LE_IN_AA(X, Y)

R is empty.
The argument filtering Pi contains the following mapping:
s(x1)  =  s(x1)
LE_IN_AA(x1, x2)  =  LE_IN_AA

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ NonTerminationProof
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP

Q DP problem:
The TRS P consists of the following rules:

LE_IN_AA → LE_IN_AA

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by semiunifying a rule from P directly.

The TRS P consists of the following rules:

LE_IN_AA → LE_IN_AA

The TRS R consists of the following rules:none


s = LE_IN_AA evaluates to t =LE_IN_AA

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:



Rewriting sequence

The DP semiunifies directly so there is only one rewrite step from LE_IN_AA to LE_IN_AA.





↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
              ↳ PiDP
              ↳ PiDP

Pi DP problem:
The TRS P consists of the following rules:

U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)
U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))

The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag([], [], [], Ls) → split_out_gaag([], [], [], Ls)
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(Xs, [], Xs, Ls) → merge_out_agaa(Xs, [], Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
merge_in_gaaa([], Xs, Xs, Ls) → merge_out_gaaa([], Xs, Xs, Ls)
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x1, x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x1, x2, x3, x4)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x1, x2, x3, x4)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa(x2)
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa(x1)
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)
U8_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GAAA(x8)
U6_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_AGAA(x8)
U6_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_GAAA(x8)
MERGE_IN_AGAA(x1, x2, x3, x4)  =  MERGE_IN_AGAA(x2)
MERGE_IN_GAAA(x1, x2, x3, x4)  =  MERGE_IN_GAAA(x1)
U8_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_AGAA(x8)

We have to consider all (P,R,Pi)-chains
For (infinitary) constructor rewriting [30] we can delete all non-usable rules from R.

↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
              ↳ PiDP
              ↳ PiDP

Pi DP problem:
The TRS P consists of the following rules:

U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → MERGE_IN_AGAA(Xs, .(Y, Ys), Zs, Ls)
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_AGAA(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)
U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → MERGE_IN_GAAA(.(X, Xs), Ys, Zs, Ls)
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_GAAA(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
MERGE_IN_GAAA(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_GAAA(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
MERGE_IN_AGAA(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_AGAA(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))

The TRS R consists of the following rules:

le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))

The argument filtering Pi contains the following mapping:
.(x1, x2)  =  .
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
s(x1)  =  s(x1)
U8_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_GAAA(x8)
U6_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_AGAA(x8)
U6_GAAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_GAAA(x8)
MERGE_IN_AGAA(x1, x2, x3, x4)  =  MERGE_IN_AGAA(x2)
MERGE_IN_GAAA(x1, x2, x3, x4)  =  MERGE_IN_GAAA(x1)
U8_AGAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_AGAA(x8)

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
              ↳ PiDP
              ↳ PiDP

Q DP problem:
The TRS P consists of the following rules:

U8_GAAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
U6_GAAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_GAAA(.) → U8_GAAA(gt_in_aa)
MERGE_IN_AGAA(.) → U8_AGAA(gt_in_aa)
U8_AGAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
MERGE_IN_AGAA(.) → U6_AGAA(le_in_aa)
U6_AGAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_GAAA(.) → U6_GAAA(le_in_aa)

The TRS R consists of the following rules:

le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))

The set Q consists of the following terms:

le_in_aa
gt_in_aa
U11_aa(x0)
U10_aa(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule MERGE_IN_AGAA(.) → U6_AGAA(le_in_aa) at position [0] we obtained the following new rules:

MERGE_IN_AGAA(.) → U6_AGAA(U11_aa(le_in_aa))
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, 0))
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, s(0)))



↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
              ↳ PiDP
              ↳ PiDP

Q DP problem:
The TRS P consists of the following rules:

MERGE_IN_AGAA(.) → U6_AGAA(U11_aa(le_in_aa))
U6_GAAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
U8_GAAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
MERGE_IN_GAAA(.) → U8_GAAA(gt_in_aa)
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, s(0)))
MERGE_IN_AGAA(.) → U8_AGAA(gt_in_aa)
U8_AGAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
U6_AGAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, 0))
MERGE_IN_GAAA(.) → U6_GAAA(le_in_aa)

The TRS R consists of the following rules:

le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))

The set Q consists of the following terms:

le_in_aa
gt_in_aa
U11_aa(x0)
U10_aa(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule MERGE_IN_GAAA(.) → U8_GAAA(gt_in_aa) at position [0] we obtained the following new rules:

MERGE_IN_GAAA(.) → U8_GAAA(gt_out_aa(s(0), 0))
MERGE_IN_GAAA(.) → U8_GAAA(U10_aa(gt_in_aa))



↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ Narrowing
              ↳ PiDP
              ↳ PiDP

Q DP problem:
The TRS P consists of the following rules:

MERGE_IN_GAAA(.) → U8_GAAA(gt_out_aa(s(0), 0))
MERGE_IN_AGAA(.) → U6_AGAA(U11_aa(le_in_aa))
U8_GAAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
U6_GAAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, s(0)))
MERGE_IN_AGAA(.) → U8_AGAA(gt_in_aa)
U8_AGAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
MERGE_IN_GAAA(.) → U8_GAAA(U10_aa(gt_in_aa))
U6_AGAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_GAAA(.) → U6_GAAA(le_in_aa)
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, 0))

The TRS R consists of the following rules:

le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))

The set Q consists of the following terms:

le_in_aa
gt_in_aa
U11_aa(x0)
U10_aa(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule MERGE_IN_GAAA(.) → U6_GAAA(le_in_aa) at position [0] we obtained the following new rules:

MERGE_IN_GAAA(.) → U6_GAAA(U11_aa(le_in_aa))
MERGE_IN_GAAA(.) → U6_GAAA(le_out_aa(0, 0))
MERGE_IN_GAAA(.) → U6_GAAA(le_out_aa(0, s(0)))



↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ Narrowing
              ↳ PiDP
              ↳ PiDP

Q DP problem:
The TRS P consists of the following rules:

U6_GAAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, s(0)))
MERGE_IN_GAAA(.) → U6_GAAA(le_out_aa(0, s(0)))
U8_AGAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
U6_AGAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_GAAA(.) → U8_GAAA(gt_out_aa(s(0), 0))
MERGE_IN_AGAA(.) → U6_AGAA(U11_aa(le_in_aa))
U8_GAAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
MERGE_IN_GAAA(.) → U6_GAAA(U11_aa(le_in_aa))
MERGE_IN_AGAA(.) → U8_AGAA(gt_in_aa)
MERGE_IN_GAAA(.) → U6_GAAA(le_out_aa(0, 0))
MERGE_IN_GAAA(.) → U8_GAAA(U10_aa(gt_in_aa))
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, 0))

The TRS R consists of the following rules:

le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))

The set Q consists of the following terms:

le_in_aa
gt_in_aa
U11_aa(x0)
U10_aa(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule MERGE_IN_AGAA(.) → U8_AGAA(gt_in_aa) at position [0] we obtained the following new rules:

MERGE_IN_AGAA(.) → U8_AGAA(gt_out_aa(s(0), 0))
MERGE_IN_AGAA(.) → U8_AGAA(U10_aa(gt_in_aa))



↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ Narrowing
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ Narrowing
                                      ↳ QDP
                                        ↳ NonTerminationProof
              ↳ PiDP
              ↳ PiDP

Q DP problem:
The TRS P consists of the following rules:

U6_GAAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, s(0)))
MERGE_IN_AGAA(.) → U8_AGAA(gt_out_aa(s(0), 0))
U8_AGAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
MERGE_IN_GAAA(.) → U6_GAAA(le_out_aa(0, s(0)))
U6_AGAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_GAAA(.) → U8_GAAA(gt_out_aa(s(0), 0))
MERGE_IN_AGAA(.) → U6_AGAA(U11_aa(le_in_aa))
MERGE_IN_AGAA(.) → U8_AGAA(U10_aa(gt_in_aa))
U8_GAAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
MERGE_IN_GAAA(.) → U6_GAAA(U11_aa(le_in_aa))
MERGE_IN_GAAA(.) → U6_GAAA(le_out_aa(0, 0))
MERGE_IN_GAAA(.) → U8_GAAA(U10_aa(gt_in_aa))
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, 0))

The TRS R consists of the following rules:

le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))

The set Q consists of the following terms:

le_in_aa
gt_in_aa
U11_aa(x0)
U10_aa(x0)

We have to consider all (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by narrowing to the left:

The TRS P consists of the following rules:

U6_GAAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, s(0)))
MERGE_IN_AGAA(.) → U8_AGAA(gt_out_aa(s(0), 0))
U8_AGAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
MERGE_IN_GAAA(.) → U6_GAAA(le_out_aa(0, s(0)))
U6_AGAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
MERGE_IN_GAAA(.) → U8_GAAA(gt_out_aa(s(0), 0))
MERGE_IN_AGAA(.) → U6_AGAA(U11_aa(le_in_aa))
MERGE_IN_AGAA(.) → U8_AGAA(U10_aa(gt_in_aa))
U8_GAAA(gt_out_aa(X, Y)) → MERGE_IN_GAAA(.)
MERGE_IN_GAAA(.) → U6_GAAA(U11_aa(le_in_aa))
MERGE_IN_GAAA(.) → U6_GAAA(le_out_aa(0, 0))
MERGE_IN_GAAA(.) → U8_GAAA(U10_aa(gt_in_aa))
MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, 0))

The TRS R consists of the following rules:

le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))


s = U6_AGAA(le_out_aa(X, Y)) evaluates to t =U6_AGAA(le_out_aa(0, s(0)))

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:



Rewriting sequence

U6_AGAA(le_out_aa(X, Y)) → MERGE_IN_AGAA(.)
with rule U6_AGAA(le_out_aa(X', Y')) → MERGE_IN_AGAA(.) at position [] and matcher [Y' / Y, X' / X]

MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, s(0)))
with rule MERGE_IN_AGAA(.) → U6_AGAA(le_out_aa(0, s(0)))

Now applying the matcher to the start term leads to a term which is equal to the last term in the rewriting sequence


All these steps are and every following step will be a correct step w.r.t to Q.





↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
              ↳ PiDP

Pi DP problem:
The TRS P consists of the following rules:

SPLIT_IN_AAAA(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → SPLIT_IN_AAAA(Xs, Zs, Ys, Ls)

The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag([], [], [], Ls) → split_out_gaag([], [], [], Ls)
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(Xs, [], Xs, Ls) → merge_out_agaa(Xs, [], Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
merge_in_gaaa([], Xs, Xs, Ls) → merge_out_gaaa([], Xs, Xs, Ls)
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x1, x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x1, x2, x3, x4)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x1, x2, x3, x4)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa(x2)
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa(x1)
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)
SPLIT_IN_AAAA(x1, x2, x3, x4)  =  SPLIT_IN_AAAA

We have to consider all (P,R,Pi)-chains
For (infinitary) constructor rewriting [30] we can delete all non-usable rules from R.

↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
              ↳ PiDP

Pi DP problem:
The TRS P consists of the following rules:

SPLIT_IN_AAAA(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → SPLIT_IN_AAAA(Xs, Zs, Ys, Ls)

R is empty.
The argument filtering Pi contains the following mapping:
.(x1, x2)  =  .
SPLIT_IN_AAAA(x1, x2, x3, x4)  =  SPLIT_IN_AAAA

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ NonTerminationProof
              ↳ PiDP

Q DP problem:
The TRS P consists of the following rules:

SPLIT_IN_AAAA → SPLIT_IN_AAAA

R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by semiunifying a rule from P directly.

The TRS P consists of the following rules:

SPLIT_IN_AAAA → SPLIT_IN_AAAA

The TRS R consists of the following rules:none


s = SPLIT_IN_AAAA evaluates to t =SPLIT_IN_AAAA

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:



Rewriting sequence

The DP semiunifies directly so there is only one rewrite step from SPLIT_IN_AAAA to SPLIT_IN_AAAA.





↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof

Pi DP problem:
The TRS P consists of the following rules:

U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → MERGESORT_IN_GAA(X2s, Y2s, Ls)
U1_GAA(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → MERGESORT_IN_GAA(X1s, Y1s, Ls)
U1_GAA(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
MERGESORT_IN_GAA(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_GAA(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))

The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag([], [], [], Ls) → split_out_gaag([], [], [], Ls)
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(Xs, [], Xs, Ls) → merge_out_agaa(Xs, [], Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
merge_in_gaaa([], Xs, Xs, Ls) → merge_out_gaaa([], Xs, Xs, Ls)
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x1, x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x1, x2, x3, x4)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x1, x2, x3, x4)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa(x2)
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa(x1)
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)
U2_GAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_GAA(x7, x8)
U1_GAA(x1, x2, x3, x4, x5, x6, x7)  =  U1_GAA(x7)
MERGESORT_IN_GAA(x1, x2, x3)  =  MERGESORT_IN_GAA(x1)

We have to consider all (P,R,Pi)-chains
For (infinitary) constructor rewriting [30] we can delete all non-usable rules from R.

↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof

Pi DP problem:
The TRS P consists of the following rules:

U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → MERGESORT_IN_GAA(X2s, Y2s, Ls)
U1_GAA(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → MERGESORT_IN_GAA(X1s, Y1s, Ls)
U1_GAA(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_GAA(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
MERGESORT_IN_GAA(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_GAA(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))

The TRS R consists of the following rules:

mergesort_in_gaa([], [], Ls) → mergesort_out_gaa([], [], Ls)
mergesort_in_gaa(.(X, []), .(X, []), Ls) → mergesort_out_gaa(.(X, []), .(X, []), Ls)
mergesort_in_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls)) → U1_gaa(X, Y, Xs, Ys, H, Ls, split_in_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls)))
split_in_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_gaag(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U1_gaa(X, Y, Xs, Ys, H, Ls, split_out_gaag(.(X, .(Y, Xs)), X1s, X2s, .(H, Ls))) → U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_in_gaa(X1s, Y1s, Ls))
U5_gaag(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_gaag(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U2_gaa(X, Y, Xs, Ys, H, Ls, X2s, mergesort_out_gaa(X1s, Y1s, Ls)) → U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_in_gaa(X2s, Y2s, Ls))
split_in_aaaa([], [], [], Ls) → split_out_aaaa([], [], [], Ls)
split_in_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls)) → U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_in_aaaa(Xs, Zs, Ys, Ls))
U3_gaa(X, Y, Xs, Ys, H, Ls, Y1s, mergesort_out_gaa(X2s, Y2s, Ls)) → U4_gaa(X, Y, Xs, Ys, H, Ls, merge_in_ggag(Y1s, Y2s, Ys, .(H, Ls)))
U5_aaaa(X, Xs, Ys, Zs, H, Ls, split_out_aaaa(Xs, Zs, Ys, Ls)) → split_out_aaaa(.(X, Xs), .(X, Ys), Zs, .(H, Ls))
U4_gaa(X, Y, Xs, Ys, H, Ls, merge_out_ggag(Y1s, Y2s, Ys, .(H, Ls))) → mergesort_out_gaa(.(X, .(Y, Xs)), Ys, .(H, Ls))
merge_in_ggag([], Xs, Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Xs, Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
merge_in_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U6_ggag(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U8_ggag(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
le_in_aa(s(X), s(Y)) → U11_aa(X, Y, le_in_aa(X, Y))
le_in_aa(0, s(0)) → le_out_aa(0, s(0))
le_in_aa(0, 0) → le_out_aa(0, 0)
U7_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
gt_in_aa(s(X), s(Y)) → U10_aa(X, Y, gt_in_aa(X, Y))
gt_in_aa(s(0), 0) → gt_out_aa(s(0), 0)
U9_ggag(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_ggag(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U11_aa(X, Y, le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa([], Xs, Xs, Ls) → merge_out_agaa([], Xs, Xs, Ls)
merge_in_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
merge_in_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U10_aa(X, Y, gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs, [], Xs, Ls) → merge_out_gaaa(Xs, [], Xs, Ls)
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls)) → U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_in_aa(X, Y))
merge_in_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls)) → U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_in_aa(X, Y))
U6_agaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U8_agaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U6_gaaa(X, Xs, Y, Ys, Zs, H, Ls, le_out_aa(X, Y)) → U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_agaa(Xs, .(Y, Ys), Zs, Ls))
U8_gaaa(X, Xs, Y, Ys, Zs, H, Ls, gt_out_aa(X, Y)) → U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_in_gaaa(.(X, Xs), Ys, Zs, Ls))
U7_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U9_agaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_agaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))
U7_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_agaa(Xs, .(Y, Ys), Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(X, Zs), .(H, Ls))
U9_gaaa(X, Xs, Y, Ys, Zs, H, Ls, merge_out_gaaa(.(X, Xs), Ys, Zs, Ls)) → merge_out_gaaa(.(X, Xs), .(Y, Ys), .(Y, Zs), .(H, Ls))

The argument filtering Pi contains the following mapping:
mergesort_in_gaa(x1, x2, x3)  =  mergesort_in_gaa(x1)
[]  =  []
mergesort_out_gaa(x1, x2, x3)  =  mergesort_out_gaa(x1, x2)
.(x1, x2)  =  .
U1_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U1_gaa(x7)
split_in_gaag(x1, x2, x3, x4)  =  split_in_gaag(x1, x4)
split_out_gaag(x1, x2, x3, x4)  =  split_out_gaag(x1, x2, x3, x4)
U5_gaag(x1, x2, x3, x4, x5, x6, x7)  =  U5_gaag(x7)
split_in_aaaa(x1, x2, x3, x4)  =  split_in_aaaa
split_out_aaaa(x1, x2, x3, x4)  =  split_out_aaaa(x1, x2, x3)
U5_aaaa(x1, x2, x3, x4, x5, x6, x7)  =  U5_aaaa(x7)
U2_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_gaa(x7, x8)
U3_gaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U3_gaa(x7, x8)
U4_gaa(x1, x2, x3, x4, x5, x6, x7)  =  U4_gaa(x7)
merge_in_ggag(x1, x2, x3, x4)  =  merge_in_ggag(x1, x2, x4)
merge_out_ggag(x1, x2, x3, x4)  =  merge_out_ggag(x1, x2, x3, x4)
U6_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_ggag(x8)
le_in_aa(x1, x2)  =  le_in_aa
U11_aa(x1, x2, x3)  =  U11_aa(x3)
le_out_aa(x1, x2)  =  le_out_aa(x1, x2)
U7_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_ggag(x8)
merge_in_agaa(x1, x2, x3, x4)  =  merge_in_agaa(x2)
merge_out_agaa(x1, x2, x3, x4)  =  merge_out_agaa(x2)
U6_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_agaa(x8)
U7_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_agaa(x8)
U8_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_agaa(x8)
gt_in_aa(x1, x2)  =  gt_in_aa
U10_aa(x1, x2, x3)  =  U10_aa(x3)
gt_out_aa(x1, x2)  =  gt_out_aa(x1, x2)
U9_agaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_agaa(x8)
merge_in_gaaa(x1, x2, x3, x4)  =  merge_in_gaaa(x1)
merge_out_gaaa(x1, x2, x3, x4)  =  merge_out_gaaa(x1)
U6_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U6_gaaa(x8)
U7_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U7_gaaa(x8)
U8_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_gaaa(x8)
U9_gaaa(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_gaaa(x8)
U8_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U8_ggag(x8)
U9_ggag(x1, x2, x3, x4, x5, x6, x7, x8)  =  U9_ggag(x8)
s(x1)  =  s(x1)
U2_GAA(x1, x2, x3, x4, x5, x6, x7, x8)  =  U2_GAA(x7, x8)
U1_GAA(x1, x2, x3, x4, x5, x6, x7)  =  U1_GAA(x7)
MERGESORT_IN_GAA(x1, x2, x3)  =  MERGESORT_IN_GAA(x1)

We have to consider all (P,R,Pi)-chains
Transforming (infinitary) constructor rewriting Pi-DP problem [30] into ordinary QDP problem [15] by application of Pi.

↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

MERGESORT_IN_GAA(.) → U1_GAA(split_in_gaag(., .))
U2_GAA(X2s, mergesort_out_gaa(X1s, Y1s)) → MERGESORT_IN_GAA(X2s)
U1_GAA(split_out_gaag(., X1s, X2s, .)) → U2_GAA(X2s, mergesort_in_gaa(X1s))
U1_GAA(split_out_gaag(., X1s, X2s, .)) → MERGESORT_IN_GAA(X1s)

The TRS R consists of the following rules:

mergesort_in_gaa([]) → mergesort_out_gaa([], [])
mergesort_in_gaa(.) → mergesort_out_gaa(., .)
mergesort_in_gaa(.) → U1_gaa(split_in_gaag(., .))
split_in_gaag(., .) → U5_gaag(split_in_aaaa)
U1_gaa(split_out_gaag(., X1s, X2s, .)) → U2_gaa(X2s, mergesort_in_gaa(X1s))
U5_gaag(split_out_aaaa(Xs, Zs, Ys)) → split_out_gaag(., ., Zs, .)
U2_gaa(X2s, mergesort_out_gaa(X1s, Y1s)) → U3_gaa(Y1s, mergesort_in_gaa(X2s))
split_in_aaaa → split_out_aaaa([], [], [])
split_in_aaaa → U5_aaaa(split_in_aaaa)
U3_gaa(Y1s, mergesort_out_gaa(X2s, Y2s)) → U4_gaa(merge_in_ggag(Y1s, Y2s, .))
U5_aaaa(split_out_aaaa(Xs, Zs, Ys)) → split_out_aaaa(., ., Zs)
U4_gaa(merge_out_ggag(Y1s, Y2s, Ys, .)) → mergesort_out_gaa(., Ys)
merge_in_ggag([], Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(., ., .) → U6_ggag(le_in_aa)
merge_in_ggag(., ., .) → U8_ggag(gt_in_aa)
U6_ggag(le_out_aa(X, Y)) → U7_ggag(merge_in_agaa(.))
U8_ggag(gt_out_aa(X, Y)) → U9_ggag(merge_in_gaaa(.))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
U7_ggag(merge_out_agaa(.)) → merge_out_ggag(., ., ., .)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U9_ggag(merge_out_gaaa(.)) → merge_out_ggag(., ., ., .)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa(Xs) → merge_out_agaa(Xs)
merge_in_agaa(.) → U6_agaa(le_in_aa)
merge_in_agaa(.) → U8_agaa(gt_in_aa)
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs) → merge_out_gaaa(Xs)
merge_in_gaaa(.) → U6_gaaa(le_in_aa)
merge_in_gaaa(.) → U8_gaaa(gt_in_aa)
U6_agaa(le_out_aa(X, Y)) → U7_agaa(merge_in_agaa(.))
U8_agaa(gt_out_aa(X, Y)) → U9_agaa(merge_in_gaaa(.))
U6_gaaa(le_out_aa(X, Y)) → U7_gaaa(merge_in_agaa(.))
U8_gaaa(gt_out_aa(X, Y)) → U9_gaaa(merge_in_gaaa(.))
U7_agaa(merge_out_agaa(.)) → merge_out_agaa(.)
U9_agaa(merge_out_gaaa(.)) → merge_out_agaa(.)
U7_gaaa(merge_out_agaa(.)) → merge_out_gaaa(.)
U9_gaaa(merge_out_gaaa(.)) → merge_out_gaaa(.)

The set Q consists of the following terms:

mergesort_in_gaa(x0)
split_in_gaag(x0, x1)
U1_gaa(x0)
U5_gaag(x0)
U2_gaa(x0, x1)
split_in_aaaa
U3_gaa(x0, x1)
U5_aaaa(x0)
U4_gaa(x0)
merge_in_ggag(x0, x1, x2)
U6_ggag(x0)
U8_ggag(x0)
le_in_aa
U7_ggag(x0)
gt_in_aa
U9_ggag(x0)
U11_aa(x0)
merge_in_agaa(x0)
U10_aa(x0)
merge_in_gaaa(x0)
U6_agaa(x0)
U8_agaa(x0)
U6_gaaa(x0)
U8_gaaa(x0)
U7_agaa(x0)
U9_agaa(x0)
U7_gaaa(x0)
U9_gaaa(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule U1_GAA(split_out_gaag(., X1s, X2s, .)) → U2_GAA(X2s, mergesort_in_gaa(X1s)) at position [1] we obtained the following new rules:

U1_GAA(split_out_gaag(., [], y1, .)) → U2_GAA(y1, mergesort_out_gaa([], []))
U1_GAA(split_out_gaag(., ., y1, .)) → U2_GAA(y1, U1_gaa(split_in_gaag(., .)))
U1_GAA(split_out_gaag(., ., y1, .)) → U2_GAA(y1, mergesort_out_gaa(., .))



↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

U1_GAA(split_out_gaag(., [], y1, .)) → U2_GAA(y1, mergesort_out_gaa([], []))
U1_GAA(split_out_gaag(., ., y1, .)) → U2_GAA(y1, U1_gaa(split_in_gaag(., .)))
MERGESORT_IN_GAA(.) → U1_GAA(split_in_gaag(., .))
U2_GAA(X2s, mergesort_out_gaa(X1s, Y1s)) → MERGESORT_IN_GAA(X2s)
U1_GAA(split_out_gaag(., X1s, X2s, .)) → MERGESORT_IN_GAA(X1s)
U1_GAA(split_out_gaag(., ., y1, .)) → U2_GAA(y1, mergesort_out_gaa(., .))

The TRS R consists of the following rules:

mergesort_in_gaa([]) → mergesort_out_gaa([], [])
mergesort_in_gaa(.) → mergesort_out_gaa(., .)
mergesort_in_gaa(.) → U1_gaa(split_in_gaag(., .))
split_in_gaag(., .) → U5_gaag(split_in_aaaa)
U1_gaa(split_out_gaag(., X1s, X2s, .)) → U2_gaa(X2s, mergesort_in_gaa(X1s))
U5_gaag(split_out_aaaa(Xs, Zs, Ys)) → split_out_gaag(., ., Zs, .)
U2_gaa(X2s, mergesort_out_gaa(X1s, Y1s)) → U3_gaa(Y1s, mergesort_in_gaa(X2s))
split_in_aaaa → split_out_aaaa([], [], [])
split_in_aaaa → U5_aaaa(split_in_aaaa)
U3_gaa(Y1s, mergesort_out_gaa(X2s, Y2s)) → U4_gaa(merge_in_ggag(Y1s, Y2s, .))
U5_aaaa(split_out_aaaa(Xs, Zs, Ys)) → split_out_aaaa(., ., Zs)
U4_gaa(merge_out_ggag(Y1s, Y2s, Ys, .)) → mergesort_out_gaa(., Ys)
merge_in_ggag([], Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(., ., .) → U6_ggag(le_in_aa)
merge_in_ggag(., ., .) → U8_ggag(gt_in_aa)
U6_ggag(le_out_aa(X, Y)) → U7_ggag(merge_in_agaa(.))
U8_ggag(gt_out_aa(X, Y)) → U9_ggag(merge_in_gaaa(.))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
U7_ggag(merge_out_agaa(.)) → merge_out_ggag(., ., ., .)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U9_ggag(merge_out_gaaa(.)) → merge_out_ggag(., ., ., .)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa(Xs) → merge_out_agaa(Xs)
merge_in_agaa(.) → U6_agaa(le_in_aa)
merge_in_agaa(.) → U8_agaa(gt_in_aa)
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs) → merge_out_gaaa(Xs)
merge_in_gaaa(.) → U6_gaaa(le_in_aa)
merge_in_gaaa(.) → U8_gaaa(gt_in_aa)
U6_agaa(le_out_aa(X, Y)) → U7_agaa(merge_in_agaa(.))
U8_agaa(gt_out_aa(X, Y)) → U9_agaa(merge_in_gaaa(.))
U6_gaaa(le_out_aa(X, Y)) → U7_gaaa(merge_in_agaa(.))
U8_gaaa(gt_out_aa(X, Y)) → U9_gaaa(merge_in_gaaa(.))
U7_agaa(merge_out_agaa(.)) → merge_out_agaa(.)
U9_agaa(merge_out_gaaa(.)) → merge_out_agaa(.)
U7_gaaa(merge_out_agaa(.)) → merge_out_gaaa(.)
U9_gaaa(merge_out_gaaa(.)) → merge_out_gaaa(.)

The set Q consists of the following terms:

mergesort_in_gaa(x0)
split_in_gaag(x0, x1)
U1_gaa(x0)
U5_gaag(x0)
U2_gaa(x0, x1)
split_in_aaaa
U3_gaa(x0, x1)
U5_aaaa(x0)
U4_gaa(x0)
merge_in_ggag(x0, x1, x2)
U6_ggag(x0)
U8_ggag(x0)
le_in_aa
U7_ggag(x0)
gt_in_aa
U9_ggag(x0)
U11_aa(x0)
merge_in_agaa(x0)
U10_aa(x0)
merge_in_gaaa(x0)
U6_agaa(x0)
U8_agaa(x0)
U6_gaaa(x0)
U8_gaaa(x0)
U7_agaa(x0)
U9_agaa(x0)
U7_gaaa(x0)
U9_gaaa(x0)

We have to consider all (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

U1_GAA(split_out_gaag(., ., y1, .)) → U2_GAA(y1, U1_gaa(split_in_gaag(., .)))
MERGESORT_IN_GAA(.) → U1_GAA(split_in_gaag(., .))
U2_GAA(X2s, mergesort_out_gaa(X1s, Y1s)) → MERGESORT_IN_GAA(X2s)
U1_GAA(split_out_gaag(., X1s, X2s, .)) → MERGESORT_IN_GAA(X1s)
U1_GAA(split_out_gaag(., ., y1, .)) → U2_GAA(y1, mergesort_out_gaa(., .))

The TRS R consists of the following rules:

mergesort_in_gaa([]) → mergesort_out_gaa([], [])
mergesort_in_gaa(.) → mergesort_out_gaa(., .)
mergesort_in_gaa(.) → U1_gaa(split_in_gaag(., .))
split_in_gaag(., .) → U5_gaag(split_in_aaaa)
U1_gaa(split_out_gaag(., X1s, X2s, .)) → U2_gaa(X2s, mergesort_in_gaa(X1s))
U5_gaag(split_out_aaaa(Xs, Zs, Ys)) → split_out_gaag(., ., Zs, .)
U2_gaa(X2s, mergesort_out_gaa(X1s, Y1s)) → U3_gaa(Y1s, mergesort_in_gaa(X2s))
split_in_aaaa → split_out_aaaa([], [], [])
split_in_aaaa → U5_aaaa(split_in_aaaa)
U3_gaa(Y1s, mergesort_out_gaa(X2s, Y2s)) → U4_gaa(merge_in_ggag(Y1s, Y2s, .))
U5_aaaa(split_out_aaaa(Xs, Zs, Ys)) → split_out_aaaa(., ., Zs)
U4_gaa(merge_out_ggag(Y1s, Y2s, Ys, .)) → mergesort_out_gaa(., Ys)
merge_in_ggag([], Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(., ., .) → U6_ggag(le_in_aa)
merge_in_ggag(., ., .) → U8_ggag(gt_in_aa)
U6_ggag(le_out_aa(X, Y)) → U7_ggag(merge_in_agaa(.))
U8_ggag(gt_out_aa(X, Y)) → U9_ggag(merge_in_gaaa(.))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
U7_ggag(merge_out_agaa(.)) → merge_out_ggag(., ., ., .)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U9_ggag(merge_out_gaaa(.)) → merge_out_ggag(., ., ., .)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa(Xs) → merge_out_agaa(Xs)
merge_in_agaa(.) → U6_agaa(le_in_aa)
merge_in_agaa(.) → U8_agaa(gt_in_aa)
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs) → merge_out_gaaa(Xs)
merge_in_gaaa(.) → U6_gaaa(le_in_aa)
merge_in_gaaa(.) → U8_gaaa(gt_in_aa)
U6_agaa(le_out_aa(X, Y)) → U7_agaa(merge_in_agaa(.))
U8_agaa(gt_out_aa(X, Y)) → U9_agaa(merge_in_gaaa(.))
U6_gaaa(le_out_aa(X, Y)) → U7_gaaa(merge_in_agaa(.))
U8_gaaa(gt_out_aa(X, Y)) → U9_gaaa(merge_in_gaaa(.))
U7_agaa(merge_out_agaa(.)) → merge_out_agaa(.)
U9_agaa(merge_out_gaaa(.)) → merge_out_agaa(.)
U7_gaaa(merge_out_agaa(.)) → merge_out_gaaa(.)
U9_gaaa(merge_out_gaaa(.)) → merge_out_gaaa(.)

The set Q consists of the following terms:

mergesort_in_gaa(x0)
split_in_gaag(x0, x1)
U1_gaa(x0)
U5_gaag(x0)
U2_gaa(x0, x1)
split_in_aaaa
U3_gaa(x0, x1)
U5_aaaa(x0)
U4_gaa(x0)
merge_in_ggag(x0, x1, x2)
U6_ggag(x0)
U8_ggag(x0)
le_in_aa
U7_ggag(x0)
gt_in_aa
U9_ggag(x0)
U11_aa(x0)
merge_in_agaa(x0)
U10_aa(x0)
merge_in_gaaa(x0)
U6_agaa(x0)
U8_agaa(x0)
U6_gaaa(x0)
U8_gaaa(x0)
U7_agaa(x0)
U9_agaa(x0)
U7_gaaa(x0)
U9_gaaa(x0)

We have to consider all (P,Q,R)-chains.
By narrowing [15] the rule MERGESORT_IN_GAA(.) → U1_GAA(split_in_gaag(., .)) at position [0] we obtained the following new rules:

MERGESORT_IN_GAA(.) → U1_GAA(U5_gaag(split_in_aaaa))



↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

U1_GAA(split_out_gaag(., ., y1, .)) → U2_GAA(y1, U1_gaa(split_in_gaag(., .)))
MERGESORT_IN_GAA(.) → U1_GAA(U5_gaag(split_in_aaaa))
U2_GAA(X2s, mergesort_out_gaa(X1s, Y1s)) → MERGESORT_IN_GAA(X2s)
U1_GAA(split_out_gaag(., X1s, X2s, .)) → MERGESORT_IN_GAA(X1s)
U1_GAA(split_out_gaag(., ., y1, .)) → U2_GAA(y1, mergesort_out_gaa(., .))

The TRS R consists of the following rules:

mergesort_in_gaa([]) → mergesort_out_gaa([], [])
mergesort_in_gaa(.) → mergesort_out_gaa(., .)
mergesort_in_gaa(.) → U1_gaa(split_in_gaag(., .))
split_in_gaag(., .) → U5_gaag(split_in_aaaa)
U1_gaa(split_out_gaag(., X1s, X2s, .)) → U2_gaa(X2s, mergesort_in_gaa(X1s))
U5_gaag(split_out_aaaa(Xs, Zs, Ys)) → split_out_gaag(., ., Zs, .)
U2_gaa(X2s, mergesort_out_gaa(X1s, Y1s)) → U3_gaa(Y1s, mergesort_in_gaa(X2s))
split_in_aaaa → split_out_aaaa([], [], [])
split_in_aaaa → U5_aaaa(split_in_aaaa)
U3_gaa(Y1s, mergesort_out_gaa(X2s, Y2s)) → U4_gaa(merge_in_ggag(Y1s, Y2s, .))
U5_aaaa(split_out_aaaa(Xs, Zs, Ys)) → split_out_aaaa(., ., Zs)
U4_gaa(merge_out_ggag(Y1s, Y2s, Ys, .)) → mergesort_out_gaa(., Ys)
merge_in_ggag([], Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(., ., .) → U6_ggag(le_in_aa)
merge_in_ggag(., ., .) → U8_ggag(gt_in_aa)
U6_ggag(le_out_aa(X, Y)) → U7_ggag(merge_in_agaa(.))
U8_ggag(gt_out_aa(X, Y)) → U9_ggag(merge_in_gaaa(.))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
U7_ggag(merge_out_agaa(.)) → merge_out_ggag(., ., ., .)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U9_ggag(merge_out_gaaa(.)) → merge_out_ggag(., ., ., .)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa(Xs) → merge_out_agaa(Xs)
merge_in_agaa(.) → U6_agaa(le_in_aa)
merge_in_agaa(.) → U8_agaa(gt_in_aa)
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs) → merge_out_gaaa(Xs)
merge_in_gaaa(.) → U6_gaaa(le_in_aa)
merge_in_gaaa(.) → U8_gaaa(gt_in_aa)
U6_agaa(le_out_aa(X, Y)) → U7_agaa(merge_in_agaa(.))
U8_agaa(gt_out_aa(X, Y)) → U9_agaa(merge_in_gaaa(.))
U6_gaaa(le_out_aa(X, Y)) → U7_gaaa(merge_in_agaa(.))
U8_gaaa(gt_out_aa(X, Y)) → U9_gaaa(merge_in_gaaa(.))
U7_agaa(merge_out_agaa(.)) → merge_out_agaa(.)
U9_agaa(merge_out_gaaa(.)) → merge_out_agaa(.)
U7_gaaa(merge_out_agaa(.)) → merge_out_gaaa(.)
U9_gaaa(merge_out_gaaa(.)) → merge_out_gaaa(.)

The set Q consists of the following terms:

mergesort_in_gaa(x0)
split_in_gaag(x0, x1)
U1_gaa(x0)
U5_gaag(x0)
U2_gaa(x0, x1)
split_in_aaaa
U3_gaa(x0, x1)
U5_aaaa(x0)
U4_gaa(x0)
merge_in_ggag(x0, x1, x2)
U6_ggag(x0)
U8_ggag(x0)
le_in_aa
U7_ggag(x0)
gt_in_aa
U9_ggag(x0)
U11_aa(x0)
merge_in_agaa(x0)
U10_aa(x0)
merge_in_gaaa(x0)
U6_agaa(x0)
U8_agaa(x0)
U6_gaaa(x0)
U8_gaaa(x0)
U7_agaa(x0)
U9_agaa(x0)
U7_gaaa(x0)
U9_gaaa(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule U1_GAA(split_out_gaag(., X1s, X2s, .)) → MERGESORT_IN_GAA(X1s) we obtained the following new rules:

U1_GAA(split_out_gaag(., ., x1, .)) → MERGESORT_IN_GAA(.)



↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ ForwardInstantiation
                                      ↳ QDP
                                        ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

U1_GAA(split_out_gaag(., ., y1, .)) → U2_GAA(y1, U1_gaa(split_in_gaag(., .)))
MERGESORT_IN_GAA(.) → U1_GAA(U5_gaag(split_in_aaaa))
U1_GAA(split_out_gaag(., ., x1, .)) → MERGESORT_IN_GAA(.)
U2_GAA(X2s, mergesort_out_gaa(X1s, Y1s)) → MERGESORT_IN_GAA(X2s)
U1_GAA(split_out_gaag(., ., y1, .)) → U2_GAA(y1, mergesort_out_gaa(., .))

The TRS R consists of the following rules:

mergesort_in_gaa([]) → mergesort_out_gaa([], [])
mergesort_in_gaa(.) → mergesort_out_gaa(., .)
mergesort_in_gaa(.) → U1_gaa(split_in_gaag(., .))
split_in_gaag(., .) → U5_gaag(split_in_aaaa)
U1_gaa(split_out_gaag(., X1s, X2s, .)) → U2_gaa(X2s, mergesort_in_gaa(X1s))
U5_gaag(split_out_aaaa(Xs, Zs, Ys)) → split_out_gaag(., ., Zs, .)
U2_gaa(X2s, mergesort_out_gaa(X1s, Y1s)) → U3_gaa(Y1s, mergesort_in_gaa(X2s))
split_in_aaaa → split_out_aaaa([], [], [])
split_in_aaaa → U5_aaaa(split_in_aaaa)
U3_gaa(Y1s, mergesort_out_gaa(X2s, Y2s)) → U4_gaa(merge_in_ggag(Y1s, Y2s, .))
U5_aaaa(split_out_aaaa(Xs, Zs, Ys)) → split_out_aaaa(., ., Zs)
U4_gaa(merge_out_ggag(Y1s, Y2s, Ys, .)) → mergesort_out_gaa(., Ys)
merge_in_ggag([], Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(., ., .) → U6_ggag(le_in_aa)
merge_in_ggag(., ., .) → U8_ggag(gt_in_aa)
U6_ggag(le_out_aa(X, Y)) → U7_ggag(merge_in_agaa(.))
U8_ggag(gt_out_aa(X, Y)) → U9_ggag(merge_in_gaaa(.))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
U7_ggag(merge_out_agaa(.)) → merge_out_ggag(., ., ., .)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U9_ggag(merge_out_gaaa(.)) → merge_out_ggag(., ., ., .)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa(Xs) → merge_out_agaa(Xs)
merge_in_agaa(.) → U6_agaa(le_in_aa)
merge_in_agaa(.) → U8_agaa(gt_in_aa)
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs) → merge_out_gaaa(Xs)
merge_in_gaaa(.) → U6_gaaa(le_in_aa)
merge_in_gaaa(.) → U8_gaaa(gt_in_aa)
U6_agaa(le_out_aa(X, Y)) → U7_agaa(merge_in_agaa(.))
U8_agaa(gt_out_aa(X, Y)) → U9_agaa(merge_in_gaaa(.))
U6_gaaa(le_out_aa(X, Y)) → U7_gaaa(merge_in_agaa(.))
U8_gaaa(gt_out_aa(X, Y)) → U9_gaaa(merge_in_gaaa(.))
U7_agaa(merge_out_agaa(.)) → merge_out_agaa(.)
U9_agaa(merge_out_gaaa(.)) → merge_out_agaa(.)
U7_gaaa(merge_out_agaa(.)) → merge_out_gaaa(.)
U9_gaaa(merge_out_gaaa(.)) → merge_out_gaaa(.)

The set Q consists of the following terms:

mergesort_in_gaa(x0)
split_in_gaag(x0, x1)
U1_gaa(x0)
U5_gaag(x0)
U2_gaa(x0, x1)
split_in_aaaa
U3_gaa(x0, x1)
U5_aaaa(x0)
U4_gaa(x0)
merge_in_ggag(x0, x1, x2)
U6_ggag(x0)
U8_ggag(x0)
le_in_aa
U7_ggag(x0)
gt_in_aa
U9_ggag(x0)
U11_aa(x0)
merge_in_agaa(x0)
U10_aa(x0)
merge_in_gaaa(x0)
U6_agaa(x0)
U8_agaa(x0)
U6_gaaa(x0)
U8_gaaa(x0)
U7_agaa(x0)
U9_agaa(x0)
U7_gaaa(x0)
U9_gaaa(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule U2_GAA(X2s, mergesort_out_gaa(X1s, Y1s)) → MERGESORT_IN_GAA(X2s) we obtained the following new rules:

U2_GAA(., mergesort_out_gaa(x1, x2)) → MERGESORT_IN_GAA(.)



↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ ForwardInstantiation
                                      ↳ QDP
                                        ↳ ForwardInstantiation
                                          ↳ QDP
                                            ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

U1_GAA(split_out_gaag(., ., y1, .)) → U2_GAA(y1, U1_gaa(split_in_gaag(., .)))
MERGESORT_IN_GAA(.) → U1_GAA(U5_gaag(split_in_aaaa))
U2_GAA(., mergesort_out_gaa(x1, x2)) → MERGESORT_IN_GAA(.)
U1_GAA(split_out_gaag(., ., x1, .)) → MERGESORT_IN_GAA(.)
U1_GAA(split_out_gaag(., ., y1, .)) → U2_GAA(y1, mergesort_out_gaa(., .))

The TRS R consists of the following rules:

mergesort_in_gaa([]) → mergesort_out_gaa([], [])
mergesort_in_gaa(.) → mergesort_out_gaa(., .)
mergesort_in_gaa(.) → U1_gaa(split_in_gaag(., .))
split_in_gaag(., .) → U5_gaag(split_in_aaaa)
U1_gaa(split_out_gaag(., X1s, X2s, .)) → U2_gaa(X2s, mergesort_in_gaa(X1s))
U5_gaag(split_out_aaaa(Xs, Zs, Ys)) → split_out_gaag(., ., Zs, .)
U2_gaa(X2s, mergesort_out_gaa(X1s, Y1s)) → U3_gaa(Y1s, mergesort_in_gaa(X2s))
split_in_aaaa → split_out_aaaa([], [], [])
split_in_aaaa → U5_aaaa(split_in_aaaa)
U3_gaa(Y1s, mergesort_out_gaa(X2s, Y2s)) → U4_gaa(merge_in_ggag(Y1s, Y2s, .))
U5_aaaa(split_out_aaaa(Xs, Zs, Ys)) → split_out_aaaa(., ., Zs)
U4_gaa(merge_out_ggag(Y1s, Y2s, Ys, .)) → mergesort_out_gaa(., Ys)
merge_in_ggag([], Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(., ., .) → U6_ggag(le_in_aa)
merge_in_ggag(., ., .) → U8_ggag(gt_in_aa)
U6_ggag(le_out_aa(X, Y)) → U7_ggag(merge_in_agaa(.))
U8_ggag(gt_out_aa(X, Y)) → U9_ggag(merge_in_gaaa(.))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
U7_ggag(merge_out_agaa(.)) → merge_out_ggag(., ., ., .)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U9_ggag(merge_out_gaaa(.)) → merge_out_ggag(., ., ., .)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa(Xs) → merge_out_agaa(Xs)
merge_in_agaa(.) → U6_agaa(le_in_aa)
merge_in_agaa(.) → U8_agaa(gt_in_aa)
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs) → merge_out_gaaa(Xs)
merge_in_gaaa(.) → U6_gaaa(le_in_aa)
merge_in_gaaa(.) → U8_gaaa(gt_in_aa)
U6_agaa(le_out_aa(X, Y)) → U7_agaa(merge_in_agaa(.))
U8_agaa(gt_out_aa(X, Y)) → U9_agaa(merge_in_gaaa(.))
U6_gaaa(le_out_aa(X, Y)) → U7_gaaa(merge_in_agaa(.))
U8_gaaa(gt_out_aa(X, Y)) → U9_gaaa(merge_in_gaaa(.))
U7_agaa(merge_out_agaa(.)) → merge_out_agaa(.)
U9_agaa(merge_out_gaaa(.)) → merge_out_agaa(.)
U7_gaaa(merge_out_agaa(.)) → merge_out_gaaa(.)
U9_gaaa(merge_out_gaaa(.)) → merge_out_gaaa(.)

The set Q consists of the following terms:

mergesort_in_gaa(x0)
split_in_gaag(x0, x1)
U1_gaa(x0)
U5_gaag(x0)
U2_gaa(x0, x1)
split_in_aaaa
U3_gaa(x0, x1)
U5_aaaa(x0)
U4_gaa(x0)
merge_in_ggag(x0, x1, x2)
U6_ggag(x0)
U8_ggag(x0)
le_in_aa
U7_ggag(x0)
gt_in_aa
U9_ggag(x0)
U11_aa(x0)
merge_in_agaa(x0)
U10_aa(x0)
merge_in_gaaa(x0)
U6_agaa(x0)
U8_agaa(x0)
U6_gaaa(x0)
U8_gaaa(x0)
U7_agaa(x0)
U9_agaa(x0)
U7_gaaa(x0)
U9_gaaa(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule U1_GAA(split_out_gaag(., ., y1, .)) → U2_GAA(y1, U1_gaa(split_in_gaag(., .))) we obtained the following new rules:

U1_GAA(split_out_gaag(., ., ., .)) → U2_GAA(., U1_gaa(split_in_gaag(., .)))



↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ ForwardInstantiation
                                      ↳ QDP
                                        ↳ ForwardInstantiation
                                          ↳ QDP
                                            ↳ ForwardInstantiation
                                              ↳ QDP
                                                ↳ ForwardInstantiation

Q DP problem:
The TRS P consists of the following rules:

MERGESORT_IN_GAA(.) → U1_GAA(U5_gaag(split_in_aaaa))
U2_GAA(., mergesort_out_gaa(x1, x2)) → MERGESORT_IN_GAA(.)
U1_GAA(split_out_gaag(., ., x1, .)) → MERGESORT_IN_GAA(.)
U1_GAA(split_out_gaag(., ., ., .)) → U2_GAA(., U1_gaa(split_in_gaag(., .)))
U1_GAA(split_out_gaag(., ., y1, .)) → U2_GAA(y1, mergesort_out_gaa(., .))

The TRS R consists of the following rules:

mergesort_in_gaa([]) → mergesort_out_gaa([], [])
mergesort_in_gaa(.) → mergesort_out_gaa(., .)
mergesort_in_gaa(.) → U1_gaa(split_in_gaag(., .))
split_in_gaag(., .) → U5_gaag(split_in_aaaa)
U1_gaa(split_out_gaag(., X1s, X2s, .)) → U2_gaa(X2s, mergesort_in_gaa(X1s))
U5_gaag(split_out_aaaa(Xs, Zs, Ys)) → split_out_gaag(., ., Zs, .)
U2_gaa(X2s, mergesort_out_gaa(X1s, Y1s)) → U3_gaa(Y1s, mergesort_in_gaa(X2s))
split_in_aaaa → split_out_aaaa([], [], [])
split_in_aaaa → U5_aaaa(split_in_aaaa)
U3_gaa(Y1s, mergesort_out_gaa(X2s, Y2s)) → U4_gaa(merge_in_ggag(Y1s, Y2s, .))
U5_aaaa(split_out_aaaa(Xs, Zs, Ys)) → split_out_aaaa(., ., Zs)
U4_gaa(merge_out_ggag(Y1s, Y2s, Ys, .)) → mergesort_out_gaa(., Ys)
merge_in_ggag([], Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(., ., .) → U6_ggag(le_in_aa)
merge_in_ggag(., ., .) → U8_ggag(gt_in_aa)
U6_ggag(le_out_aa(X, Y)) → U7_ggag(merge_in_agaa(.))
U8_ggag(gt_out_aa(X, Y)) → U9_ggag(merge_in_gaaa(.))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
U7_ggag(merge_out_agaa(.)) → merge_out_ggag(., ., ., .)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U9_ggag(merge_out_gaaa(.)) → merge_out_ggag(., ., ., .)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa(Xs) → merge_out_agaa(Xs)
merge_in_agaa(.) → U6_agaa(le_in_aa)
merge_in_agaa(.) → U8_agaa(gt_in_aa)
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs) → merge_out_gaaa(Xs)
merge_in_gaaa(.) → U6_gaaa(le_in_aa)
merge_in_gaaa(.) → U8_gaaa(gt_in_aa)
U6_agaa(le_out_aa(X, Y)) → U7_agaa(merge_in_agaa(.))
U8_agaa(gt_out_aa(X, Y)) → U9_agaa(merge_in_gaaa(.))
U6_gaaa(le_out_aa(X, Y)) → U7_gaaa(merge_in_agaa(.))
U8_gaaa(gt_out_aa(X, Y)) → U9_gaaa(merge_in_gaaa(.))
U7_agaa(merge_out_agaa(.)) → merge_out_agaa(.)
U9_agaa(merge_out_gaaa(.)) → merge_out_agaa(.)
U7_gaaa(merge_out_agaa(.)) → merge_out_gaaa(.)
U9_gaaa(merge_out_gaaa(.)) → merge_out_gaaa(.)

The set Q consists of the following terms:

mergesort_in_gaa(x0)
split_in_gaag(x0, x1)
U1_gaa(x0)
U5_gaag(x0)
U2_gaa(x0, x1)
split_in_aaaa
U3_gaa(x0, x1)
U5_aaaa(x0)
U4_gaa(x0)
merge_in_ggag(x0, x1, x2)
U6_ggag(x0)
U8_ggag(x0)
le_in_aa
U7_ggag(x0)
gt_in_aa
U9_ggag(x0)
U11_aa(x0)
merge_in_agaa(x0)
U10_aa(x0)
merge_in_gaaa(x0)
U6_agaa(x0)
U8_agaa(x0)
U6_gaaa(x0)
U8_gaaa(x0)
U7_agaa(x0)
U9_agaa(x0)
U7_gaaa(x0)
U9_gaaa(x0)

We have to consider all (P,Q,R)-chains.
By forward instantiating [14] the rule U1_GAA(split_out_gaag(., ., y1, .)) → U2_GAA(y1, mergesort_out_gaa(., .)) we obtained the following new rules:

U1_GAA(split_out_gaag(., ., ., .)) → U2_GAA(., mergesort_out_gaa(., .))



↳ Prolog
  ↳ PrologToPiTRSProof
  ↳ PrologToPiTRSProof
    ↳ PiTRS
      ↳ DependencyPairsProof
        ↳ PiDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
              ↳ PiDP
                ↳ UsableRulesProof
                  ↳ PiDP
                    ↳ PiDPToQDPProof
                      ↳ QDP
                        ↳ Narrowing
                          ↳ QDP
                            ↳ DependencyGraphProof
                              ↳ QDP
                                ↳ Narrowing
                                  ↳ QDP
                                    ↳ ForwardInstantiation
                                      ↳ QDP
                                        ↳ ForwardInstantiation
                                          ↳ QDP
                                            ↳ ForwardInstantiation
                                              ↳ QDP
                                                ↳ ForwardInstantiation
                                                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

MERGESORT_IN_GAA(.) → U1_GAA(U5_gaag(split_in_aaaa))
U2_GAA(., mergesort_out_gaa(x1, x2)) → MERGESORT_IN_GAA(.)
U1_GAA(split_out_gaag(., ., ., .)) → U2_GAA(., mergesort_out_gaa(., .))
U1_GAA(split_out_gaag(., ., x1, .)) → MERGESORT_IN_GAA(.)
U1_GAA(split_out_gaag(., ., ., .)) → U2_GAA(., U1_gaa(split_in_gaag(., .)))

The TRS R consists of the following rules:

mergesort_in_gaa([]) → mergesort_out_gaa([], [])
mergesort_in_gaa(.) → mergesort_out_gaa(., .)
mergesort_in_gaa(.) → U1_gaa(split_in_gaag(., .))
split_in_gaag(., .) → U5_gaag(split_in_aaaa)
U1_gaa(split_out_gaag(., X1s, X2s, .)) → U2_gaa(X2s, mergesort_in_gaa(X1s))
U5_gaag(split_out_aaaa(Xs, Zs, Ys)) → split_out_gaag(., ., Zs, .)
U2_gaa(X2s, mergesort_out_gaa(X1s, Y1s)) → U3_gaa(Y1s, mergesort_in_gaa(X2s))
split_in_aaaa → split_out_aaaa([], [], [])
split_in_aaaa → U5_aaaa(split_in_aaaa)
U3_gaa(Y1s, mergesort_out_gaa(X2s, Y2s)) → U4_gaa(merge_in_ggag(Y1s, Y2s, .))
U5_aaaa(split_out_aaaa(Xs, Zs, Ys)) → split_out_aaaa(., ., Zs)
U4_gaa(merge_out_ggag(Y1s, Y2s, Ys, .)) → mergesort_out_gaa(., Ys)
merge_in_ggag([], Xs, Ls) → merge_out_ggag([], Xs, Xs, Ls)
merge_in_ggag(Xs, [], Ls) → merge_out_ggag(Xs, [], Xs, Ls)
merge_in_ggag(., ., .) → U6_ggag(le_in_aa)
merge_in_ggag(., ., .) → U8_ggag(gt_in_aa)
U6_ggag(le_out_aa(X, Y)) → U7_ggag(merge_in_agaa(.))
U8_ggag(gt_out_aa(X, Y)) → U9_ggag(merge_in_gaaa(.))
le_in_aa → U11_aa(le_in_aa)
le_in_aa → le_out_aa(0, s(0))
le_in_aa → le_out_aa(0, 0)
U7_ggag(merge_out_agaa(.)) → merge_out_ggag(., ., ., .)
gt_in_aa → U10_aa(gt_in_aa)
gt_in_aa → gt_out_aa(s(0), 0)
U9_ggag(merge_out_gaaa(.)) → merge_out_ggag(., ., ., .)
U11_aa(le_out_aa(X, Y)) → le_out_aa(s(X), s(Y))
merge_in_agaa(Xs) → merge_out_agaa(Xs)
merge_in_agaa(.) → U6_agaa(le_in_aa)
merge_in_agaa(.) → U8_agaa(gt_in_aa)
U10_aa(gt_out_aa(X, Y)) → gt_out_aa(s(X), s(Y))
merge_in_gaaa(Xs) → merge_out_gaaa(Xs)
merge_in_gaaa(.) → U6_gaaa(le_in_aa)
merge_in_gaaa(.) → U8_gaaa(gt_in_aa)
U6_agaa(le_out_aa(X, Y)) → U7_agaa(merge_in_agaa(.))
U8_agaa(gt_out_aa(X, Y)) → U9_agaa(merge_in_gaaa(.))
U6_gaaa(le_out_aa(X, Y)) → U7_gaaa(merge_in_agaa(.))
U8_gaaa(gt_out_aa(X, Y)) → U9_gaaa(merge_in_gaaa(.))
U7_agaa(merge_out_agaa(.)) → merge_out_agaa(.)
U9_agaa(merge_out_gaaa(.)) → merge_out_agaa(.)
U7_gaaa(merge_out_agaa(.)) → merge_out_gaaa(.)
U9_gaaa(merge_out_gaaa(.)) → merge_out_gaaa(.)

The set Q consists of the following terms:

mergesort_in_gaa(x0)
split_in_gaag(x0, x1)
U1_gaa(x0)
U5_gaag(x0)
U2_gaa(x0, x1)
split_in_aaaa
U3_gaa(x0, x1)
U5_aaaa(x0)
U4_gaa(x0)
merge_in_ggag(x0, x1, x2)
U6_ggag(x0)
U8_ggag(x0)
le_in_aa
U7_ggag(x0)
gt_in_aa
U9_ggag(x0)
U11_aa(x0)
merge_in_agaa(x0)
U10_aa(x0)
merge_in_gaaa(x0)
U6_agaa(x0)
U8_agaa(x0)
U6_gaaa(x0)
U8_gaaa(x0)
U7_agaa(x0)
U9_agaa(x0)
U7_gaaa(x0)
U9_gaaa(x0)

We have to consider all (P,Q,R)-chains.